From c7acd2b7dd75534d931888a01d14d7f6dec5f717 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 16 Apr 2020 21:05:39 +0400 Subject: [PATCH 01/27] Extend TypeSelector and MethodSelector API --- .../Types/MethodInfoSelector.cs | 11 ++ Src/FluentAssertions/Types/TypeSelector.cs | 90 +++++++++ .../Types/MethodInfoSelectorSpecs.cs | 24 +++ .../Types/TypeSelectorSpecs.cs | 178 +++++++++++++++++- 4 files changed, 302 insertions(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/MethodInfoSelector.cs b/Src/FluentAssertions/Types/MethodInfoSelector.cs index 56edd80fd6..f752a97660 100644 --- a/Src/FluentAssertions/Types/MethodInfoSelector.cs +++ b/Src/FluentAssertions/Types/MethodInfoSelector.cs @@ -128,6 +128,17 @@ public MethodInfoSelector ThatAreNotDecoratedWithOrInherit() return this; } + /// + /// Select return types of methods + /// + /// + public TypeSelector ReturnTypes() + { + var returnTypes = selectedMethods.Select(mi => mi.ReturnType); + + return new TypeSelector(returnTypes); + } + /// /// The resulting objects. /// diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index 2b77072216..44502485b1 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; +using System.Threading.Tasks; using FluentAssertions.Common; namespace FluentAssertions.Types @@ -166,6 +167,95 @@ public TypeSelector ThatAreNotUnderNamespace(string @namespace) return this; } + /// + /// Determines whether the type is class + /// + public TypeSelector ThatAreClasses() + { + types = types.Where(t => t.IsClass).ToList(); + return this; + } + /// + /// Determines whether the type is not a class + /// + public TypeSelector ThatAreNotClasses() + { + types = types.Where(t => !t.IsClass).ToList(); + return this; + } + + /// + /// Determines whether the type is a static class + /// + public TypeSelector ThatAreStaticClasses() + { + types = types.Where(t => t.IsCSharpStatic()).ToList(); + return this; + } + + /// + /// Determines whether the type is not a static class + /// + public TypeSelector ThatAreNotStaticClasses() + { + types = types.Where(t => !t.IsCSharpStatic()).ToList(); + return this; + } + + /// + /// Determines whether the type satisfies the predicate passed + /// + public TypeSelector ThatAre(Func predicate) + { + types = types.Where(predicate).ToList(); + return this; + } + /// + /// Returns T for the types which are Task<T>; the type itself otherwise + /// + public TypeSelector UnwrapTaskTypes() + { + types = types.Select(type => + { + if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>)) + { + return type.GetGenericArguments().Single(); + } + return type == typeof(Task) ? typeof(void) : type; + }).ToList(); + + return this; + } + + /// + /// Returns T for the types which are IEnumerable<T>; the type itself otherwise + /// + public TypeSelector UnwrapEnumerableTypes() + { + types = types + .Select(type => + { + if (type.IsGenericType) + { + if (type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) + { + return type.GetGenericArguments().Single(); + } + + var iEnumerableDefinition = type.GetInterfaces() + .SingleOrDefault(iType => iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(IEnumerable<>)); + if (iEnumerableDefinition != null) + { + return iEnumerableDefinition.GetGenericArguments().Single(); + } + } + + return type; + }).ToList(); + + return this; + } + /// /// Returns an enumerator that iterates through the collection. /// diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs index 295206f34b..36173b38f3 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs @@ -242,6 +242,22 @@ public void When_selecting_methods_not_decorated_with_or_inheriting_a_noninherit // Assert methods.Should().ContainSingle(); } + [Fact] + public void When_selecting_methods_return_types_it_should_return_the_correct_types() + { + // Arrange + Type type = typeof(TestClassForMethodReturnTypesSelector); + + // Act + IEnumerable returnTypes = type.Methods().ReturnTypes().ToArray(); + + // Assert + returnTypes.Should() + .HaveCount(3) + .And.Contain(typeof(void)) + .And.Contain(typeof(int)) + .And.Contain(typeof(string)); + } } #region Internal classes used in unit tests @@ -308,6 +324,14 @@ internal class TestClassForMethodSelectorWithNonInheritableAttributeDerived : Te public override void PublicVirtualVoidMethodWithAttribute() { } } + internal class TestClassForMethodReturnTypesSelector + { + public void SomeMethod() { } + public int AnotherMethod() { return default; } + public string OneMoreMethod() { return default; } + } + + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)] public class DummyMethodNonInheritableAttributeAttribute : Attribute { diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index bbdad973cd..070316c9db 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -1,13 +1,17 @@ using System; using System.Collections.Generic; using System.Reflection; - +using System.Threading.Tasks; using FluentAssertions.Types; using Internal.Main.Test; +using Internal.NotOnlyClasses.Test; using Internal.Other.Test; using Internal.Other.Test.Common; +using Internal.StaticAndNonStaticClasses.Test; +using Internal.UnwrapSelectorTestTypes.Test; using Xunit; +using ISomeInterface = Internal.Main.Test.ISomeInterface; namespace FluentAssertions.Specs { @@ -415,6 +419,141 @@ public void When_deselecting_a_prefix_of_a_namespace_it_should_not_match() // Assert filteredTypes.As>().Should().ContainSingle(); } + + [Fact] + public void When_selecting_types_that_are_classes_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(NotOnlyClassesClass).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.NotOnlyClasses.Test") + .ThatAreClasses(); + + // Assert + types.Should().ContainSingle() + .Which.Should().Be(typeof(NotOnlyClassesClass)); + } + + [Fact] + public void When_selecting_types_that_are_not_classes_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(NotOnlyClassesClass).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.NotOnlyClasses.Test") + .ThatAreNotClasses(); + + // Assert + types.Should() + .HaveCount(2) + .And.Contain(typeof(INotOnlyClassesInterface)) + .And.Contain(typeof(NotOnlyClassesEnumeration)); + } + + [Fact] + public void When_selecting_types_that_are_static_classes_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(StaticClass).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.StaticAndNonStaticClasses.Test") + .ThatAreStaticClasses(); + + // Assert + types.Should() + .ContainSingle() + .Which.Should().Be(typeof(StaticClass)); + } + + [Fact] + public void When_selecting_types_that_are_not_static_classes_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(StaticClass).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.StaticAndNonStaticClasses.Test") + .ThatAreNotStaticClasses(); + + // Assert + types.Should() + .ContainSingle() + .Which.Should().Be(typeof(NotAStaticClass)); + } + + [Fact] + public void When_selecting_types_with_predicate_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(SomeBaseClass).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAre(t => t.GetCustomAttribute() != null); + + // Assert + types.Should() + .HaveCount(3) + .And.Contain(typeof(ClassWithSomeAttribute)) + .And.Contain(typeof(ClassWithSomeAttributeDerived)) + .And.Contain(typeof(ClassWithSomeAttributeThatImplementsSomeInterface)); + } + + + [Fact] + public void When_unwrap_task_types_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(ClassToExploreItsMethodsReturnValues).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.UnwrapSelectorTestTypes.Test") + .Methods() + .ReturnTypes() + .UnwrapTaskTypes(); + + // Assert + types.Should() + // Void will be twice here - for void itself and for non-generic Task + .HaveCount(6) + .And.Contain(typeof(void)) + .And.Contain(typeof(int)) + .And.Contain(typeof(bool)) + .And.Contain(typeof(List)) + .And.Contain(typeof(IEnumerable)); + } + + [Fact] + public void When_unwrap_enumerable_types_it_should_return_the_correct_types() + { + // Arrange + Assembly assembly = typeof(ClassToExploreItsMethodsReturnValues).GetTypeInfo().Assembly; + + // Act + IEnumerable types = AllTypes.From(assembly) + .ThatAreInNamespace("Internal.UnwrapSelectorTestTypes.Test") + .Methods() + .ReturnTypes() + .UnwrapEnumerableTypes(); + + // Assert + types.Should() + .HaveCount(6) + .And.Contain(typeof(void)) + .And.Contain(typeof(int)) + .And.Contain(typeof(Task)) + .And.Contain(typeof(Task)) + .And.Contain(typeof(string)) + .And.Contain(typeof(long)); + } } } @@ -510,6 +649,43 @@ internal class SomeCommonClass } } +namespace Internal.NotOnlyClasses.Test +{ + internal class NotOnlyClassesClass + { + } + internal enum NotOnlyClassesEnumeration + { + } + internal interface INotOnlyClassesInterface + { + } +} + +namespace Internal.StaticAndNonStaticClasses.Test +{ + internal static class StaticClass + { + } + internal class NotAStaticClass + { + } +} + +namespace Internal.UnwrapSelectorTestTypes.Test +{ + internal class ClassToExploreItsMethodsReturnValues + { + internal void Do() { } + internal int DoWithInt() { return default; } + internal Task DoWithTask() { return Task.CompletedTask; } + internal Task DoWithTaskBoolean() { return Task.FromResult(true); } + internal List DoWithListOfString() { return default; } + internal IEnumerable DoWithEnumerableOfBooleans() { return default; } + + } +} + #pragma warning disable RCS1110 // Declare type inside namespace. internal class ClassInGlobalNamespace { } #pragma warning restore RCS1110 From af94d17129a7633bd72a2e9081997dbf7ec61fcb Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 16 Apr 2020 21:56:36 +0400 Subject: [PATCH 02/27] Add sealed checks to TypeSelectorAssertions --- .../Types/TypeSelectorAssertions.cs | 17 ++++- .../Types/TypeAssertionSpecs.cs | 66 +++++++++++++++++++ 2 files changed, 82 insertions(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs index 55c7561a8d..4b529ffbd6 100644 --- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs @@ -291,7 +291,22 @@ public AndConstraint NotBeDecoratedWithOrInherit(this); } - + public AndConstraint BeSealed(string because = "", params object[] becauseArgs) + { + var notSealedTypes = Subject.Where(type => !type.IsCSharpSealed()).ToArray(); + Execute.Assertion.ForCondition(!notSealedTypes.Any()) + .BecauseOf(because, becauseArgs) + .FailWith("Expected all types to be sealed{reason}, but the following types are not:{0}{1}.", Environment.NewLine, GetDescriptionsFor(notSealedTypes)); + return new AndConstraint(this); + } + public AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) + { + var sealedTypes = Subject.Where(type => type.IsCSharpSealed()).ToArray(); + Execute.Assertion.ForCondition(!sealedTypes.Any()) + .BecauseOf(because, becauseArgs) + .FailWith("Expected all types not to be sealed{reason}, but the following types are:{0}{1}.", Environment.NewLine, GetDescriptionsFor(sealedTypes)); + return new AndConstraint(this); + } private static string GetDescriptionsFor(IEnumerable types) { string[] descriptions = types.Select(GetDescriptionFor).ToArray(); diff --git a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.cs index 150212aa6d..239d5c090c 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeAssertionSpecs.cs @@ -1592,6 +1592,39 @@ public void When_type_is_not_valid_for_BeSealed_it_throws_exception(Type type, s .WithMessage(exceptionMessage); } + [Fact] + public void When_all_types_are_sealed_it_succeeds() + { + // Arrange + var types = new TypeSelector(new[] + { + typeof(Sealed) + }); + + // Act / Assert + types.Should().BeSealed(); + } + + [Fact] + public void When_any_type_is_not_sealed_it_fails_with_a_meaningful_message() + { + // Arrange + var types = new TypeSelector(new[] + { + typeof(Sealed), + typeof(Abstract) + }); + + // Act + Action act = () => types.Should().BeSealed("it's {0} important", "very"); + + // Assert + act.Should().Throw() + .WithMessage("Expected all types to be sealed because it's very important, but the following types are not:" + + "*Abstract*" + + "."); + } + #endregion #region NotBeSealed @@ -1648,6 +1681,39 @@ public void When_type_is_not_valid_for_NotBeSealed_it_throws_exception(Type type .WithMessage(exceptionMessage); } + [Fact] + public void When_all_types_are_not_sealed_it_succeeds() + { + // Arrange + var types = new TypeSelector(new[] + { + typeof(Abstract) + }); + + // Act / Assert + types.Should().NotBeSealed(); + } + + [Fact] + public void When_any_type_is_sealed_it_fails_with_a_meaningful_message() + { + // Arrange + var types = new TypeSelector(new[] + { + typeof(Abstract), + typeof(Sealed) + }); + + // Act + Action act = () => types.Should().NotBeSealed("it's {0} important", "very"); + + // Assert + act.Should().Throw() + .WithMessage("Expected all types not to be sealed because it's very important, but the following types are:" + + "*Sealed*" + + "."); + } + #endregion #region BeAbstract From 9c92646c49fd94fdd38d7dc35682c97c8da92d07 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 16 Apr 2020 22:03:35 +0400 Subject: [PATCH 03/27] XML-docs added --- .../Types/TypeSelectorAssertions.cs | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs index 4b529ffbd6..990523cf14 100644 --- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs @@ -291,6 +291,17 @@ public AndConstraint NotBeDecoratedWithOrInherit(this); } + + /// + /// Asserts that the all are sealed classes + /// + /// + /// 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 BeSealed(string because = "", params object[] becauseArgs) { var notSealedTypes = Subject.Where(type => !type.IsCSharpSealed()).ToArray(); @@ -299,6 +310,17 @@ public AndConstraint BeSealed(string because = "", param .FailWith("Expected all types to be sealed{reason}, but the following types are not:{0}{1}.", Environment.NewLine, GetDescriptionsFor(notSealedTypes)); return new AndConstraint(this); } + + /// + /// Asserts that the all are not sealed classes + /// + /// + /// 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 NotBeSealed(string because = "", params object[] becauseArgs) { var sealedTypes = Subject.Where(type => type.IsCSharpSealed()).ToArray(); From ff7292c8543eb58ff8559135e69472f30ccb463d Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 16 Apr 2020 22:27:45 +0400 Subject: [PATCH 04/27] Extend MethodInfoSelectorAssertions --- .../Types/MethodInfoSelectorAssertions.cs | 38 ++++++++ .../Types/MethodInfoAssertionSpecs.cs | 25 +++++ .../Types/MethodInfoSelectorAssertionSpecs.cs | 97 +++++++++++++++++++ 3 files changed, 160 insertions(+) diff --git a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs index 04da39fa8d..bb065efd87 100644 --- a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs @@ -205,6 +205,44 @@ public AndConstraint NotBeDecoratedWith(this); } + /// + /// Asserts that the selected methods have access modifier + /// that matches the specified . + /// + /// + /// 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 Be(CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) + { + var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() != accessModifier).ToArray(); + var message = $"Expected all selected methods to be {accessModifier}{{reason}}, but the following methods are not:" + Environment.NewLine + GetDescriptionsFor(methods); + Execute.Assertion.ForCondition(!methods.Any()).BecauseOf(because, becauseArgs).FailWith(message); + return new AndConstraint(this); + } + + /// + /// Asserts that the selected methods doesn't have access modifier + /// specified with . + /// + /// + /// 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 NotBe(CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs) + { + var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() == accessModifier).ToArray(); + var message = $"Expected all selected methods to not be {accessModifier}{{reason}}, but the following methods are:" + Environment.NewLine + GetDescriptionsFor(methods); + Execute.Assertion.ForCondition(!methods.Any()).BecauseOf(because, becauseArgs).FailWith(message); + return new AndConstraint(this); + } + private MethodInfo[] GetMethodsWithout(Expression> isMatchingPredicate) where TAttribute : Attribute { diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs index 3e9d23960f..61aac39956 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs @@ -647,5 +647,30 @@ internal class ClassWithMethodWithImplementationAttribute public void ZeroOptions() { } } + internal class ClassWithPublicMethods + { + public void PublicDoNothing() + { + } + + public void DoNothingWithParameter(int i) + { + } + } + internal class ClassWithNonPublicMethods + { + protected void PublicDoNothing() + { + } + + internal void DoNothingWithParameter(int i) + { + } + + private void DoNothingWithAnotherParameter(string i) + { + } + } + #endregion } diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs index 6bb81120c3..a61b79ab87 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs @@ -1,4 +1,5 @@ using System; +using FluentAssertions.Common; using FluentAssertions.Types; using Xunit; using Xunit.Sdk; @@ -231,5 +232,101 @@ public void When_asserting_methods_are_not_decorated_with_attribute_but_they_are "*ClassWithAllMethodsDecoratedWithDummyAttribute.ProtectedDoNothing*" + "*ClassWithAllMethodsDecoratedWithDummyAttribute.PrivateDoNothing"); } + + + + [Fact] + public void When_asserting_methods_have_specified_accessor_it_should_succeed() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().Be(CSharpAccessModifier.Public); + + // Assert + act.Should().NotThrow(); + } + + [Fact] + public void When_asserting_methods_does_not_have_specified_accessor_it_should_throw() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().Be(CSharpAccessModifier.Public); + + // Assert + act.Should().Throw(); + } + + [Fact] + public void When_asserting_methods_does_not_have_specified_accessor_it_should_throw_with_descriptive_message() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().Be(CSharpAccessModifier.Public, "we want to test the error {0}", "message"); + + // Assert + act.Should().Throw() + .WithMessage("Expected all selected methods to be Public" + + " because we want to test the error message," + + " but the following methods are not:*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.PublicDoNothing*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithParameter*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithAnotherParameter"); + } + + [Fact] + public void When_asserting_methods_does_not_have_specified_accessor_it_should_succeed() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().NotBe(CSharpAccessModifier.Public); + + // Assert + act.Should().NotThrow(); + } + + [Fact] + public void When_asserting_methods_have_specified_accessor_it_should_throw() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().NotBe(CSharpAccessModifier.Public); + + // Assert + act.Should().Throw(); + } + + [Fact] + public void When_asserting_methods_have_specified_accessor_it_should_throw_with_descriptive_message() + { + // Arrange + var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); + + // Act + Action act = () => + methodSelector.Should().NotBe(CSharpAccessModifier.Public, "we want to test the error {0}", "message"); + + // Assert + act.Should().Throw() + .WithMessage("Expected all selected methods to not be Public" + + " because we want to test the error message," + + " but the following methods are:*" + + "Void FluentAssertions.Specs.ClassWithPublicMethods.PublicDoNothing*"); + } } } From 234a0af4ab6debeca365e99ca4974519b3015ded Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Fri, 17 Apr 2020 09:39:26 +0400 Subject: [PATCH 05/27] Fix broken link to the documentation --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 0907a1aa16..42df5a7de0 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -5,4 +5,4 @@ No open-source project is going to be successful without contributions. After we * The [Pull Request](https://help.github.com/articles/using-pull-requests) is targeted at the `develop` branch. * The code complies with the [Coding Guidelines for C# 3.0, 4.0 and 5.0](https://csharpcodingguidelines.com/)/. * The changes are covered by a new or existing set of unit tests which follow the Arrange-Act-Assert syntax such as is used [in this example](https://github.com/fluentassertions/fluentassertions/blob/daaf35b9b59b622c96d0c034e8972a020b2bee55/Tests/FluentAssertions.Shared.Specs/BasicEquivalencySpecs.cs#L33). -* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/documentation/). +* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/introduction/). From a1fbaa9331936f6bbcfa31aeb20392aade2afec7 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Fri, 17 Apr 2020 10:01:19 +0400 Subject: [PATCH 06/27] Cleanup --- .../TypeEnumerableExtensions.cs | 55 +++++++++++++++++++ .../Types/MethodInfoSelector.cs | 2 +- .../Types/MethodInfoSelectorAssertions.cs | 6 +- Src/FluentAssertions/Types/TypeSelector.cs | 5 +- 4 files changed, 61 insertions(+), 7 deletions(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index bd6042de90..b1ab4cdcd7 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -77,5 +77,60 @@ public static IEnumerable ThatImplement(this IEnumerable types) { return new TypeSelector(types).ThatImplement(); } + + /// + /// Filters to only include types that are classes. + /// + public static IEnumerable ThatAreClasses(this IEnumerable types) + { + return new TypeSelector(types).ThatAreClasses(); + } + + /// + /// Filters to only include types that are not classes. + /// + public static IEnumerable ThatAreNotClasses(this IEnumerable types) + { + return new TypeSelector(types).ThatAreClasses(); + } + /// + /// Filters to only include types that are static classes. + /// + public static IEnumerable ThatAreStaticClasses(this IEnumerable types) + { + return new TypeSelector(types).ThatAreStaticClasses(); + } + + /// + /// Filters to only include types that are not static classes. + /// + public static IEnumerable ThatAreNotStaticClasses(this IEnumerable types) + { + return new TypeSelector(types).ThatAreStaticClasses(); + } + + /// + /// Filters to only include types that satisfies the passed. + /// + public static IEnumerable ThatAre(this IEnumerable types, Func predicate) + { + return new TypeSelector(types).ThatAre(predicate); + } + + /// + /// Returns T for the types which are Task<T>; the type itself otherwise + /// + public static IEnumerable UnwrapTaskTypes(this IEnumerable types) + { + return new TypeSelector(types).UnwrapTaskTypes(); + } + + /// + /// Returns T for the types which are IEnumerable<T> or implement the IEnumerable<T>; the type itself otherwise + /// + public static IEnumerable UnwrapEnumerableTypes(this IEnumerable types) + { + return new TypeSelector(types).UnwrapEnumerableTypes(); + } } } diff --git a/Src/FluentAssertions/Types/MethodInfoSelector.cs b/Src/FluentAssertions/Types/MethodInfoSelector.cs index f752a97660..5140121599 100644 --- a/Src/FluentAssertions/Types/MethodInfoSelector.cs +++ b/Src/FluentAssertions/Types/MethodInfoSelector.cs @@ -129,7 +129,7 @@ public MethodInfoSelector ThatAreNotDecoratedWithOrInherit() } /// - /// Select return types of methods + /// Select return types of the methods /// /// public TypeSelector ReturnTypes() diff --git a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs index bb065efd87..bd6ba64e53 100644 --- a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs @@ -206,8 +206,7 @@ public AndConstraint NotBeDecoratedWith - /// Asserts that the selected methods have access modifier - /// that matches the specified . + /// Asserts that the selected methods have specified . /// /// /// A formatted phrase as is supported by explaining why the assertion @@ -225,8 +224,7 @@ public AndConstraint Be(CSharpAccessModifier acces } /// - /// Asserts that the selected methods doesn't have access modifier - /// specified with . + /// Asserts that the selected methods don't have specified /// /// /// A formatted phrase as is supported by explaining why the assertion diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index 44502485b1..b6a3c64793 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -203,13 +203,14 @@ public TypeSelector ThatAreNotStaticClasses() } /// - /// Determines whether the type satisfies the predicate passed + /// Allows to filter the types with the passed /// public TypeSelector ThatAre(Func predicate) { types = types.Where(predicate).ToList(); return this; } + /// /// Returns T for the types which are Task<T>; the type itself otherwise /// @@ -228,7 +229,7 @@ public TypeSelector UnwrapTaskTypes() } /// - /// Returns T for the types which are IEnumerable<T>; the type itself otherwise + /// Returns T for the types which are IEnumerable<T> or implement the IEnumerable<T>; the type itself otherwise /// public TypeSelector UnwrapEnumerableTypes() { From 31019c5e0b8dee8376310b2dece7c4e84bbc2ae5 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 23 Apr 2020 11:58:03 +0400 Subject: [PATCH 07/27] Fix some of PR comments --- .../TypeEnumerableExtensions.cs | 4 ++-- .../Types/MethodInfoSelectorAssertions.cs | 14 ++++++++++++-- .../Types/TypeSelectorAssertions.cs | 4 ++++ .../FluentAssertions/net47.approved.txt | 19 +++++++++++++++++++ .../netcoreapp2.1.approved.txt | 19 +++++++++++++++++++ .../netcoreapp3.0.approved.txt | 19 +++++++++++++++++++ .../netstandard2.0.approved.txt | 19 +++++++++++++++++++ .../netstandard2.1.approved.txt | 19 +++++++++++++++++++ 8 files changed, 113 insertions(+), 4 deletions(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index b1ab4cdcd7..e2094805c4 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -91,7 +91,7 @@ public static IEnumerable ThatAreClasses(this IEnumerable types) /// public static IEnumerable ThatAreNotClasses(this IEnumerable types) { - return new TypeSelector(types).ThatAreClasses(); + return new TypeSelector(types).ThatAreNotClasses(); } /// /// Filters to only include types that are static classes. @@ -106,7 +106,7 @@ public static IEnumerable ThatAreStaticClasses(this IEnumerable type /// public static IEnumerable ThatAreNotStaticClasses(this IEnumerable types) { - return new TypeSelector(types).ThatAreStaticClasses(); + return new TypeSelector(types).ThatAreNotStaticClasses(); } /// diff --git a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs index bd6ba64e53..aa60766afe 100644 --- a/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs @@ -219,7 +219,12 @@ public AndConstraint Be(CSharpAccessModifier acces { var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() != accessModifier).ToArray(); var message = $"Expected all selected methods to be {accessModifier}{{reason}}, but the following methods are not:" + Environment.NewLine + GetDescriptionsFor(methods); - Execute.Assertion.ForCondition(!methods.Any()).BecauseOf(because, becauseArgs).FailWith(message); + + Execute.Assertion + .ForCondition(!methods.Any()) + .BecauseOf(because, becauseArgs) + .FailWith(message); + return new AndConstraint(this); } @@ -237,7 +242,12 @@ public AndConstraint NotBe(CSharpAccessModifier ac { var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() == accessModifier).ToArray(); var message = $"Expected all selected methods to not be {accessModifier}{{reason}}, but the following methods are:" + Environment.NewLine + GetDescriptionsFor(methods); - Execute.Assertion.ForCondition(!methods.Any()).BecauseOf(because, becauseArgs).FailWith(message); + + Execute.Assertion + .ForCondition(!methods.Any()) + .BecauseOf(because, becauseArgs) + .FailWith(message); + return new AndConstraint(this); } diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs index 990523cf14..749bfb7787 100644 --- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs @@ -305,9 +305,11 @@ public AndConstraint NotBeDecoratedWithOrInherit BeSealed(string because = "", params object[] becauseArgs) { var notSealedTypes = Subject.Where(type => !type.IsCSharpSealed()).ToArray(); + Execute.Assertion.ForCondition(!notSealedTypes.Any()) .BecauseOf(because, becauseArgs) .FailWith("Expected all types to be sealed{reason}, but the following types are not:{0}{1}.", Environment.NewLine, GetDescriptionsFor(notSealedTypes)); + return new AndConstraint(this); } @@ -324,9 +326,11 @@ public AndConstraint BeSealed(string because = "", param public AndConstraint NotBeSealed(string because = "", params object[] becauseArgs) { var sealedTypes = Subject.Where(type => type.IsCSharpSealed()).ToArray(); + Execute.Assertion.ForCondition(!sealedTypes.Any()) .BecauseOf(because, becauseArgs) .FailWith("Expected all types not to be sealed{reason}, but the following types are:{0}{1}.", Environment.NewLine, GetDescriptionsFor(sealedTypes)); + return new AndConstraint(this); } private static string GetDescriptionsFor(IEnumerable types) diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt index 6bf6c8fe00..31aa933735 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt @@ -229,18 +229,25 @@ namespace FluentAssertions } public static class TypeEnumerableExtensions { + public static System.Collections.Generic.IEnumerable ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(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 UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } } public static class TypeExtensions { @@ -1929,6 +1936,7 @@ namespace FluentAssertions.Types 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 ThatAreDecoratedWith() where TAttribute : System.Attribute { } public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() @@ -1946,11 +1954,13 @@ namespace FluentAssertions.Types 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 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 NotBeDecoratedWith(string because = "", params object[] becauseArgs) where TAttribute : System.Attribute { } public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) @@ -2091,23 +2101,30 @@ namespace FluentAssertions.Types public TypeSelector(System.Collections.Generic.IEnumerable types) { } public TypeSelector(System.Type type) { } public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAre(System.Func predicate) { } + 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 ThatAreNotStaticClasses() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } 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 System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } } public class TypeSelectorAssertions { @@ -2121,6 +2138,7 @@ namespace FluentAssertions.Types 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 BeSealed(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) @@ -2129,6 +2147,7 @@ namespace FluentAssertions.Types 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 NotBeSealed(string because = "", params object[] becauseArgs) { } } } namespace FluentAssertions.Xml diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt index 0a6c928255..e3579f2f15 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt @@ -229,18 +229,25 @@ namespace FluentAssertions } public static class TypeEnumerableExtensions { + public static System.Collections.Generic.IEnumerable ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(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 UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } } public static class TypeExtensions { @@ -1929,6 +1936,7 @@ namespace FluentAssertions.Types 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 ThatAreDecoratedWith() where TAttribute : System.Attribute { } public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() @@ -1946,11 +1954,13 @@ namespace FluentAssertions.Types 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 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 NotBeDecoratedWith(string because = "", params object[] becauseArgs) where TAttribute : System.Attribute { } public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) @@ -2091,23 +2101,30 @@ namespace FluentAssertions.Types public TypeSelector(System.Collections.Generic.IEnumerable types) { } public TypeSelector(System.Type type) { } public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAre(System.Func predicate) { } + 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 ThatAreNotStaticClasses() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } 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 System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } } public class TypeSelectorAssertions { @@ -2121,6 +2138,7 @@ namespace FluentAssertions.Types 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 BeSealed(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) @@ -2129,6 +2147,7 @@ namespace FluentAssertions.Types 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 NotBeSealed(string because = "", params object[] becauseArgs) { } } } namespace FluentAssertions.Xml diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt index d58ae06b33..4b83fb8aec 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt @@ -229,18 +229,25 @@ namespace FluentAssertions } public static class TypeEnumerableExtensions { + public static System.Collections.Generic.IEnumerable ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(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 UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } } public static class TypeExtensions { @@ -1929,6 +1936,7 @@ namespace FluentAssertions.Types 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 ThatAreDecoratedWith() where TAttribute : System.Attribute { } public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() @@ -1946,11 +1954,13 @@ namespace FluentAssertions.Types 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 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 NotBeDecoratedWith(string because = "", params object[] becauseArgs) where TAttribute : System.Attribute { } public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) @@ -2091,23 +2101,30 @@ namespace FluentAssertions.Types public TypeSelector(System.Collections.Generic.IEnumerable types) { } public TypeSelector(System.Type type) { } public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAre(System.Func predicate) { } + 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 ThatAreNotStaticClasses() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } 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 System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } } public class TypeSelectorAssertions { @@ -2121,6 +2138,7 @@ namespace FluentAssertions.Types 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 BeSealed(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) @@ -2129,6 +2147,7 @@ namespace FluentAssertions.Types 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 NotBeSealed(string because = "", params object[] becauseArgs) { } } } namespace FluentAssertions.Xml diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt index 313f6d9568..09aeb91440 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt @@ -228,18 +228,25 @@ namespace FluentAssertions } public static class TypeEnumerableExtensions { + public static System.Collections.Generic.IEnumerable ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(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 UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } } public static class TypeExtensions { @@ -1885,6 +1892,7 @@ namespace FluentAssertions.Types 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 ThatAreDecoratedWith() where TAttribute : System.Attribute { } public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() @@ -1902,11 +1910,13 @@ namespace FluentAssertions.Types 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 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 NotBeDecoratedWith(string because = "", params object[] becauseArgs) where TAttribute : System.Attribute { } public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) @@ -2047,23 +2057,30 @@ namespace FluentAssertions.Types public TypeSelector(System.Collections.Generic.IEnumerable types) { } public TypeSelector(System.Type type) { } public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAre(System.Func predicate) { } + 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 ThatAreNotStaticClasses() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } 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 System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } } public class TypeSelectorAssertions { @@ -2077,6 +2094,7 @@ namespace FluentAssertions.Types 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 BeSealed(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) @@ -2085,6 +2103,7 @@ namespace FluentAssertions.Types 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 NotBeSealed(string because = "", params object[] becauseArgs) { } } } namespace FluentAssertions.Xml diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt index 5497f97ab4..fc6ac93a22 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt @@ -229,18 +229,25 @@ namespace FluentAssertions } public static class TypeEnumerableExtensions { + public static System.Collections.Generic.IEnumerable ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(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 UnwrapEnumerableTypes(this System.Collections.Generic.IEnumerable types) { } + public static System.Collections.Generic.IEnumerable UnwrapTaskTypes(this System.Collections.Generic.IEnumerable types) { } } public static class TypeExtensions { @@ -1929,6 +1936,7 @@ namespace FluentAssertions.Types 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 ThatAreDecoratedWith() where TAttribute : System.Attribute { } public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() @@ -1946,11 +1954,13 @@ namespace FluentAssertions.Types 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 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 NotBeDecoratedWith(string because = "", params object[] becauseArgs) where TAttribute : System.Attribute { } public FluentAssertions.AndConstraint NotBeDecoratedWith(System.Linq.Expressions.Expression> isMatchingAttributePredicate, string because = "", params object[] becauseArgs) @@ -2091,23 +2101,30 @@ namespace FluentAssertions.Types public TypeSelector(System.Collections.Generic.IEnumerable types) { } public TypeSelector(System.Type type) { } public System.Collections.Generic.IEnumerator GetEnumerator() { } + public FluentAssertions.Types.TypeSelector ThatAre(System.Func predicate) { } + 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 ThatAreNotStaticClasses() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } + public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } 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 System.Type[] ToArray() { } + public FluentAssertions.Types.TypeSelector UnwrapEnumerableTypes() { } + public FluentAssertions.Types.TypeSelector UnwrapTaskTypes() { } } public class TypeSelectorAssertions { @@ -2121,6 +2138,7 @@ namespace FluentAssertions.Types 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 BeSealed(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) @@ -2129,6 +2147,7 @@ namespace FluentAssertions.Types 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 NotBeSealed(string because = "", params object[] becauseArgs) { } } } namespace FluentAssertions.Xml From 14780bc35307bda3bad1089b7d2c64134e68b5d8 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 23 Apr 2020 12:17:23 +0400 Subject: [PATCH 08/27] Change test names to more descriptive --- .../Types/MethodInfoSelectorAssertionSpecs.cs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs index a61b79ab87..eabacbca3e 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs @@ -236,7 +236,7 @@ public void When_asserting_methods_are_not_decorated_with_attribute_but_they_are [Fact] - public void When_asserting_methods_have_specified_accessor_it_should_succeed() + public void When_all_methods_have_specified_accessor_it_should_succeed() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); @@ -250,7 +250,7 @@ public void When_asserting_methods_have_specified_accessor_it_should_succeed() } [Fact] - public void When_asserting_methods_does_not_have_specified_accessor_it_should_throw() + public void When_not_all_methods_have_specified_accessor_it_should_throw() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); @@ -264,7 +264,7 @@ public void When_asserting_methods_does_not_have_specified_accessor_it_should_th } [Fact] - public void When_asserting_methods_does_not_have_specified_accessor_it_should_throw_with_descriptive_message() + public void When_not_all_methods_have_specified_accessor_it_should_throw_with_descriptive_message() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); @@ -284,7 +284,7 @@ public void When_asserting_methods_does_not_have_specified_accessor_it_should_th } [Fact] - public void When_asserting_methods_does_not_have_specified_accessor_it_should_succeed() + public void When_all_methods_does_not_have_specified_accessor_it_should_succeed() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods)); @@ -298,7 +298,7 @@ public void When_asserting_methods_does_not_have_specified_accessor_it_should_su } [Fact] - public void When_asserting_methods_have_specified_accessor_it_should_throw() + public void When_any_method_have_specified_accessor_it_should_throw() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); @@ -312,7 +312,7 @@ public void When_asserting_methods_have_specified_accessor_it_should_throw() } [Fact] - public void When_asserting_methods_have_specified_accessor_it_should_throw_with_descriptive_message() + public void When_any_method_have_specified_accessor_it_should_throw_with_descriptive_message() { // Arrange var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods)); From e48d943332769934f2eb3851912514e6528b8852 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 23 Apr 2020 12:37:14 +0400 Subject: [PATCH 09/27] Add exception message assertions to the tests --- .../Types/MethodInfoSelectorAssertionSpecs.cs | 20 +++++++++++++------ .../Types/TypeSelectorSpecs.cs | 3 ++- 2 files changed, 16 insertions(+), 7 deletions(-) diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs index eabacbca3e..5c762ffe83 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs @@ -260,7 +260,12 @@ public void When_not_all_methods_have_specified_accessor_it_should_throw() methodSelector.Should().Be(CSharpAccessModifier.Public); // Assert - act.Should().Throw(); + act.Should().Throw() + .WithMessage("Expected all selected methods to be Public" + + ", but the following methods are not:*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.PublicDoNothing*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithParameter*" + + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithAnotherParameter"); } [Fact] @@ -276,8 +281,8 @@ public void When_not_all_methods_have_specified_accessor_it_should_throw_with_de // Assert act.Should().Throw() .WithMessage("Expected all selected methods to be Public" + - " because we want to test the error message," + - " but the following methods are not:*" + + " because we want to test the error message" + + ", but the following methods are not:*" + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.PublicDoNothing*" + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithParameter*" + "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithAnotherParameter"); @@ -308,7 +313,10 @@ public void When_any_method_have_specified_accessor_it_should_throw() methodSelector.Should().NotBe(CSharpAccessModifier.Public); // Assert - act.Should().Throw(); + act.Should().Throw() + .WithMessage("Expected all selected methods to not be Public" + + ", but the following methods are:*" + + "Void FluentAssertions.Specs.ClassWithPublicMethods.PublicDoNothing*"); } [Fact] @@ -324,8 +332,8 @@ public void When_any_method_have_specified_accessor_it_should_throw_with_descrip // Assert act.Should().Throw() .WithMessage("Expected all selected methods to not be Public" + - " because we want to test the error message," + - " but the following methods are:*" + + " because we want to test the error message" + + ", but the following methods are:*" + "Void FluentAssertions.Specs.ClassWithPublicMethods.PublicDoNothing*"); } } diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index a924649860..63d34619f9 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -432,7 +432,8 @@ public void When_selecting_types_that_are_classes_it_should_return_the_correct_t .ThatAreClasses(); // Assert - types.Should().ContainSingle() + types.Should() + .ContainSingle() .Which.Should().Be(typeof(NotOnlyClassesClass)); } From b122067e6758305f51e65ccbc0838b5c936e479f Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 23 Apr 2020 12:59:52 +0400 Subject: [PATCH 10/27] Update the docs --- docs/_pages/typesandmethods.md | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/docs/_pages/typesandmethods.md b/docs/_pages/typesandmethods.md index 79dd2a469b..b6651baa38 100644 --- a/docs/_pages/typesandmethods.md +++ b/docs/_pages/typesandmethods.md @@ -63,6 +63,30 @@ typeof(MyController).Methods() "because all Actions with HttpPost require ValidateAntiForgeryToken"); ``` +You can also perform assertions on all of methods return types to check class contract. +Like this: + +```csharp +typeof(MyDataReader).Methods() + .ReturnTypes() + .Properties() + .Should() + .NotBeWritable("all the return types should be immutable"); +``` + +If the methods return types are `IEnumerable` or `Task` you can unwrap underlying types to with `UnwrapTaskTypes` and `UnwrapEnumerableTypes` methods. +Like this: + +```csharp +typeof(MyDataReader).Methods() + .ReturnTypes() + .UnwrapTaskTypes() + .UnwrapEnumerableTypes() + .Properties() + .Should() + .NotBeWritable("all the return types should be immutable"); +``` + If you also want to assert that an attribute has a specific property value, use this syntax. ```csharp From ea1d746aba561939a58d9c63a3f73d0d4d5f7309 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Thu, 23 Apr 2020 18:17:26 +0400 Subject: [PATCH 11/27] Add missing tests and release notes --- .../TypeEnumerableExtensionsSpecs.cs | 245 ++++++++++++++++++ docs/_pages/releases.md | 12 + 2 files changed, 257 insertions(+) create mode 100644 Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs diff --git a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs new file mode 100644 index 0000000000..f5c3cf6f72 --- /dev/null +++ b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs @@ -0,0 +1,245 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using FluentAssertions.Common; +using TypeEnumerableExtensionsSpecs.BaseNamespace; +using TypeEnumerableExtensionsSpecs.BaseNamespace.Nested; +using TypeEnumerableExtensionsSpecs.Internal; +using Xunit; + +namespace FluentAssertions.Specs +{ + public class TypeEnumerableExtensionsSpecs + { + [Fact] + public void When_selecting_types_that_decorated_with_attribute_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(ClassWithSomeAttribute), typeof(ClassDerivedFromClassWithSomeAttribute) }; + + types.ThatAreDecoratedWith() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(ClassWithSomeAttribute)); + } + + [Fact] + public void When_selecting_types_that_decorated_with_attribute_or_inherit_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(ClassWithSomeAttribute), typeof(ClassDerivedFromClassWithSomeAttribute) }; + + types.ThatAreDecoratedWithOrInherit() + .Should() + .HaveCount(2) + .And.Contain(typeof(ClassWithSomeAttribute)) + .And.Contain(typeof(ClassDerivedFromClassWithSomeAttribute)); + } + + [Fact] + public void When_selecting_types_that_not_decorated_with_attribute_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(ClassWithSomeAttribute), typeof(ClassDerivedFromClassWithSomeAttribute) }; + + types.ThatAreNotDecoratedWith() + .Should() + .HaveCount(2) + .And.Contain(typeof(JustAClass)) + .And.Contain(typeof(ClassDerivedFromClassWithSomeAttribute)); + } + + [Fact] + public void When_selecting_types_that_not_decorated_with_attribute_or_inherit_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(ClassWithSomeAttribute), typeof(ClassDerivedFromClassWithSomeAttribute) }; + + types.ThatAreNotDecoratedWithOrInherit() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(JustAClass)); + } + + [Fact] + public void When_selecting_types_in_namespace_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(BaseNamespaceClass), typeof(NestedNamespaceClass) }; + + types.ThatAreInNamespace(typeof(BaseNamespaceClass).Namespace) + .Should() + .ContainSingle() + .Which.Should().Be(typeof(BaseNamespaceClass)); + } + + [Fact] + public void When_selecting_types_under_namespace_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(BaseNamespaceClass), typeof(NestedNamespaceClass) }; + + types.ThatAreUnderNamespace(typeof(BaseNamespaceClass).Namespace) + .Should() + .HaveCount(2) + .And.Contain(typeof(BaseNamespaceClass)) + .And.Contain(typeof(NestedNamespaceClass)); + } + + [Fact] + public void When_selecting_derived_classes_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(SomeBaseClass), typeof(SomeClassDerivedFromSomeBaseClass) }; + + types.ThatDeriveFrom() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(SomeClassDerivedFromSomeBaseClass)); + } + + [Fact] + public void When_selecting_types_that_implement_interface_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(ClassImplementingJustAnInterface), typeof(IJustAnInterface) }; + + types.ThatImplement() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(ClassImplementingJustAnInterface)); + } + + [Fact] + public void When_selecting_only_the_classes_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(IJustAnInterface) }; + + types.ThatAreClasses() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(JustAClass)); + } + + [Fact] + public void When_selecting_not_a_classes_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(IJustAnInterface) }; + + types.ThatAreNotClasses() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(IJustAnInterface)); + } + + [Fact] + public void When_selecting_static_classes_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; + + types.ThatAreStaticClasses() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(AStaticClass)); + } + + [Fact] + public void When_selecting_not_a_static_classes_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; + + types.ThatAreNotStaticClasses() + .Should() + .ContainSingle() + .Which.Should().Be(typeof(JustAClass)); + } + + [Fact] + public void When_selecting_types_with_predicate_it_should_return_the_correct_type() + { + var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; + + types.ThatAre(t => t.IsCSharpStatic()) + .Should() + .ContainSingle() + .Which.Should().Be(typeof(AStaticClass)); + } + + [Fact] + public void When_unwrap_task_types_it_should_return_the_correct_type() + { + var types = new[] { typeof(Task), typeof(List) }; + + types.UnwrapTaskTypes() + .Should() + .HaveCount(2) + .And.Contain(typeof(JustAClass)) + .And.Contain(typeof(List)); + } + + [Fact] + public void When_unwrap_enumerable_types_it_should_return_the_correct_type() + { + var types = new[] { typeof(Task), typeof(List) }; + + types.UnwrapEnumerableTypes() + .Should() + .HaveCount(2) + .And.Contain(typeof(Task)) + .And.Contain(typeof(IJustAnInterface)); + } + } +} + +#region Internal classes used in unit tests + +namespace TypeEnumerableExtensionsSpecs.BaseNamespace +{ + internal class BaseNamespaceClass + { + + } +} +namespace TypeEnumerableExtensionsSpecs.BaseNamespace.Nested +{ + internal class NestedNamespaceClass + { + + } +} + +namespace TypeEnumerableExtensionsSpecs.Internal +{ + internal interface IJustAnInterface + { + + } + internal class JustAClass + { + + } + internal static class AStaticClass + { + + } + + internal class SomeBaseClass + { + + } + internal class SomeClassDerivedFromSomeBaseClass : SomeBaseClass + { + + } + + internal class ClassImplementingJustAnInterface : IJustAnInterface + { + } + + [Some] + internal class ClassWithSomeAttribute + { + + } + internal class ClassDerivedFromClassWithSomeAttribute : ClassWithSomeAttribute + { + + } + [AttributeUsage(AttributeTargets.Class, Inherited = true)] + internal class SomeAttribute : Attribute + { + } +} +#endregion diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index 6f0cce251a..f3ebc70ca2 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -21,6 +21,18 @@ sidebar: * Make `DefaultValueFormatter` and `EnumerableValueFormatter` suitable for inheritance - [#1295](https://github.com/fluentassertions/fluentassertions/pull/1295). * Added support for dictionary assertions on `IReadOnlyDictionary` - [#1298](https://github.com/fluentassertions/fluentassertions/pull/1298). * `GenericAsyncFunctionAssertions` now has `AndWhichConstraint` overloads for `NotThrow[Async]` and `NotThrowAfter[Async]` - [#1289](https://github.com/fluentassertions/fluentassertions/pull/1289). +* Added `ReturnTypes` to `MethodInfoSelector` to get all return types from all the methods selected +* Added `Be` to `MethodInfoSelector` to check that methods have specified access modifier +* Added `NotBe` to `MethodInfoSelector` to check that methods doesn't have specified access modifier +* Added `ThatAreClasses` to `TypeSelector` +* Added `ThatAreNotClasses` to `TypeSelector` +* Added `ThatAreStaticClasses` to `TypeSelector` +* Added `ThatAreNotStaticClasses` to `TypeSelector` +* Added `ThatAre` to `TypeSelector` to filter types with specified predicate +* Added `UnwrapEnumerableTypes` to `TypeSelector` to get the `T` type from types implementing `IEnumerable` +* Added `UnwrapTaskTypes` to `TypeSelector` to get the `T` type for any type that are `Task` +* Added `BeSealed` to `TypeSelectorAssertions` +* Added `NotBeSealed` to `TypeSelectorAssertions` **Fixes** * Reported actual value when it contained `{{{{` or `}}}}` - [#1234](https://github.com/fluentassertions/fluentassertions/pull/1234). From c1c9525fa0e1c9098d1f11ad83dfce535baaf6aa Mon Sep 17 00:00:00 2001 From: Fedor Shchudlo Date: Fri, 24 Apr 2020 12:54:05 +0400 Subject: [PATCH 12/27] Update Src/FluentAssertions/TypeEnumerableExtensions.cs Co-Authored-By: Jonas Nyrup --- Src/FluentAssertions/TypeEnumerableExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index e2094805c4..a52e4a05f2 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -118,7 +118,7 @@ public static IEnumerable ThatAre(this IEnumerable types, Func - /// Returns T for the types which are Task<T>; the type itself otherwise + /// Returns T for the types which are ; the type itself otherwise /// public static IEnumerable UnwrapTaskTypes(this IEnumerable types) { From 64b1848647b1076638dc5785f7c00312a41b2491 Mon Sep 17 00:00:00 2001 From: Fedor Shchudlo Date: Fri, 24 Apr 2020 12:54:59 +0400 Subject: [PATCH 13/27] Update CONTRIBUTING.md Co-Authored-By: Jonas Nyrup --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 42df5a7de0..74a49d36c1 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -5,4 +5,4 @@ No open-source project is going to be successful without contributions. After we * The [Pull Request](https://help.github.com/articles/using-pull-requests) is targeted at the `develop` branch. * The code complies with the [Coding Guidelines for C# 3.0, 4.0 and 5.0](https://csharpcodingguidelines.com/)/. * The changes are covered by a new or existing set of unit tests which follow the Arrange-Act-Assert syntax such as is used [in this example](https://github.com/fluentassertions/fluentassertions/blob/daaf35b9b59b622c96d0c034e8972a020b2bee55/Tests/FluentAssertions.Shared.Specs/BasicEquivalencySpecs.cs#L33). -* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/introduction/). +* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/introduction). From 9297c5ff2a542d63ba10553d54ac18d0fce39ff3 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Fri, 24 Apr 2020 15:16:28 +0400 Subject: [PATCH 14/27] PR comments fixes --- .../TypeEnumerableExtensions.cs | 10 +-- Src/FluentAssertions/Types/TypeSelector.cs | 51 +++++++------ .../FluentAssertions/net47.approved.txt | 8 +-- .../netcoreapp2.1.approved.txt | 8 +-- .../netcoreapp3.0.approved.txt | 8 +-- .../netstandard2.0.approved.txt | 8 +-- .../netstandard2.1.approved.txt | 8 +-- .../TypeEnumerableExtensionsSpecs.cs | 4 +- .../Types/MethodInfoSelectorAssertionSpecs.cs | 4 +- .../Types/MethodInfoSelectorSpecs.cs | 2 +- .../Types/TypeSelectorSpecs.cs | 72 ++++++++++--------- docs/_pages/releases.md | 13 ++-- 12 files changed, 101 insertions(+), 95 deletions(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index a52e4a05f2..d44a00ab08 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -96,17 +96,17 @@ public static IEnumerable ThatAreNotClasses(this IEnumerable types) /// /// Filters to only include types that are static classes. /// - public static IEnumerable ThatAreStaticClasses(this IEnumerable types) + public static IEnumerable ThatAreStatic(this IEnumerable types) { - return new TypeSelector(types).ThatAreStaticClasses(); + return new TypeSelector(types).ThatAreStatic(); } /// /// Filters to only include types that are not static classes. /// - public static IEnumerable ThatAreNotStaticClasses(this IEnumerable types) + public static IEnumerable ThatAreNotStatic(this IEnumerable types) { - return new TypeSelector(types).ThatAreNotStaticClasses(); + return new TypeSelector(types).ThatAreNotStatic(); } /// @@ -118,7 +118,7 @@ public static IEnumerable ThatAre(this IEnumerable types, Func - /// Returns T for the types which are ; the type itself otherwise + /// Returns T for the types which are Task<T> or ValueTask<T>; the type itself otherwise /// public static IEnumerable UnwrapTaskTypes(this IEnumerable types) { diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index b729cc9397..3cd3c9371a 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -2,7 +2,6 @@ using System.Collections; using System.Collections.Generic; using System.Linq; -using System.Reflection; using System.Threading.Tasks; using FluentAssertions.Common; @@ -187,7 +186,7 @@ public TypeSelector ThatAreNotClasses() /// /// Determines whether the type is a static class /// - public TypeSelector ThatAreStaticClasses() + public TypeSelector ThatAreStatic() { types = types.Where(t => t.IsCSharpStatic()).ToList(); return this; @@ -196,7 +195,7 @@ public TypeSelector ThatAreStaticClasses() /// /// Determines whether the type is not a static class /// - public TypeSelector ThatAreNotStaticClasses() + public TypeSelector ThatAreNotStatic() { types = types.Where(t => !t.IsCSharpStatic()).ToList(); return this; @@ -212,7 +211,7 @@ public TypeSelector ThatAre(Func predicate) } /// - /// Returns T for the types which are Task<T>; the type itself otherwise + /// Returns T for the types which are Task<T> or ValueTask<T>; the type itself otherwise /// public TypeSelector UnwrapTaskTypes() { @@ -222,6 +221,10 @@ public TypeSelector UnwrapTaskTypes() { return type.GetGenericArguments().Single(); } + if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>)) + { + return type.GetGenericArguments().Single(); + } return type == typeof(Task) ? typeof(void) : type; }).ToList(); @@ -233,27 +236,33 @@ public TypeSelector UnwrapTaskTypes() /// public TypeSelector UnwrapEnumerableTypes() { - types = types - .Select(type => + var unwrappedTypes = new List(); + foreach (Type type in types) + { + if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) + { + unwrappedTypes.Add(type.GetGenericArguments().Single()); + } + else { - if (type.IsGenericType) + var iEnumerableImplementations = type + .GetInterfaces() + .Where(iType => iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) + .Select(ied => ied.GetGenericArguments().Single()) + .ToList(); + + if (iEnumerableImplementations.Any()) { - if (type.GetGenericTypeDefinition() == typeof(IEnumerable<>)) - { - return type.GetGenericArguments().Single(); - } - - var iEnumerableDefinition = type.GetInterfaces() - .SingleOrDefault(iType => iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(IEnumerable<>)); - if (iEnumerableDefinition != null) - { - return iEnumerableDefinition.GetGenericArguments().Single(); - } + unwrappedTypes.AddRange(iEnumerableImplementations); } + else + { + unwrappedTypes.Add(type); + } + } + } - return type; - }).ToList(); - + types = unwrappedTypes; return this; } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt index 31aa933735..03c6457460 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt @@ -241,8 +241,8 @@ namespace FluentAssertions 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(this System.Collections.Generic.IEnumerable types) { } + 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) { } @@ -2114,9 +2114,9 @@ namespace FluentAssertions.Types public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() where TAttribute : System.Attribute { } public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt index e3579f2f15..1be1531417 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt @@ -241,8 +241,8 @@ namespace FluentAssertions 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(this System.Collections.Generic.IEnumerable types) { } + 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) { } @@ -2114,9 +2114,9 @@ namespace FluentAssertions.Types public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() where TAttribute : System.Attribute { } public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt index 4b83fb8aec..c7021eb9ec 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt @@ -241,8 +241,8 @@ namespace FluentAssertions 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(this System.Collections.Generic.IEnumerable types) { } + 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) { } @@ -2114,9 +2114,9 @@ namespace FluentAssertions.Types public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() where TAttribute : System.Attribute { } public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt index 09aeb91440..0440cbe153 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt @@ -240,8 +240,8 @@ namespace FluentAssertions 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(this System.Collections.Generic.IEnumerable types) { } + 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) { } @@ -2070,9 +2070,9 @@ namespace FluentAssertions.Types public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() where TAttribute : System.Attribute { } public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt index fc6ac93a22..58d09a0b9a 100644 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt @@ -241,8 +241,8 @@ namespace FluentAssertions 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 ThatAreNotStaticClasses(this System.Collections.Generic.IEnumerable types) { } - public static System.Collections.Generic.IEnumerable ThatAreStaticClasses(this System.Collections.Generic.IEnumerable types) { } + 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) { } @@ -2114,9 +2114,9 @@ namespace FluentAssertions.Types public FluentAssertions.Types.TypeSelector ThatAreNotDecoratedWithOrInherit() where TAttribute : System.Attribute { } public FluentAssertions.Types.TypeSelector ThatAreNotInNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreNotStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreNotStatic() { } public FluentAssertions.Types.TypeSelector ThatAreNotUnderNamespace(string @namespace) { } - public FluentAssertions.Types.TypeSelector ThatAreStaticClasses() { } + public FluentAssertions.Types.TypeSelector ThatAreStatic() { } public FluentAssertions.Types.TypeSelector ThatAreUnderNamespace(string @namespace) { } public FluentAssertions.Types.TypeSelector ThatDeriveFrom() { } public FluentAssertions.Types.TypeSelector ThatDoNotDeriveFrom() { } diff --git a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs index f5c3cf6f72..6d87a5db52 100644 --- a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs +++ b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs @@ -129,7 +129,7 @@ public void When_selecting_static_classes_it_should_return_the_correct_type() { var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; - types.ThatAreStaticClasses() + types.ThatAreStatic() .Should() .ContainSingle() .Which.Should().Be(typeof(AStaticClass)); @@ -140,7 +140,7 @@ public void When_selecting_not_a_static_classes_it_should_return_the_correct_typ { var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; - types.ThatAreNotStaticClasses() + types.ThatAreNotStatic() .Should() .ContainSingle() .Which.Should().Be(typeof(JustAClass)); diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs index 5c762ffe83..1c877a9809 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorAssertionSpecs.cs @@ -232,9 +232,7 @@ public void When_asserting_methods_are_not_decorated_with_attribute_but_they_are "*ClassWithAllMethodsDecoratedWithDummyAttribute.ProtectedDoNothing*" + "*ClassWithAllMethodsDecoratedWithDummyAttribute.PrivateDoNothing"); } - - - + [Fact] public void When_all_methods_have_specified_accessor_it_should_succeed() { diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs index 98f3404978..add9215066 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoSelectorSpecs.cs @@ -242,6 +242,7 @@ public void When_selecting_methods_not_decorated_with_or_inheriting_a_noninherit // Assert methods.Should().ContainSingle(); } + [Fact] public void When_selecting_methods_return_types_it_should_return_the_correct_types() { @@ -331,7 +332,6 @@ internal class TestClassForMethodReturnTypesSelector public string OneMoreMethod() { return default; } } - [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)] public class DummyMethodNonInheritableAttributeAttribute : Attribute { diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index 63d34619f9..e32fdbbc55 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.Collections.Generic; using System.Reflection; using System.Threading.Tasks; @@ -464,7 +465,7 @@ public void When_selecting_types_that_are_static_classes_it_should_return_the_co // Act IEnumerable types = AllTypes.From(assembly) .ThatAreInNamespace("Internal.StaticAndNonStaticClasses.Test") - .ThatAreStaticClasses(); + .ThatAreStatic(); // Assert types.Should() @@ -481,7 +482,7 @@ public void When_selecting_types_that_are_not_static_classes_it_should_return_th // Act IEnumerable types = AllTypes.From(assembly) .ThatAreInNamespace("Internal.StaticAndNonStaticClasses.Test") - .ThatAreNotStaticClasses(); + .ThatAreNotStatic(); // Assert types.Should() @@ -511,49 +512,33 @@ public void When_selecting_types_with_predicate_it_should_return_the_correct_typ [Fact] public void When_unwrap_task_types_it_should_return_the_correct_types() { - // Arrange - Assembly assembly = typeof(ClassToExploreItsMethodsReturnValues).GetTypeInfo().Assembly; - - // Act - IEnumerable types = AllTypes.From(assembly) - .ThatAreInNamespace("Internal.UnwrapSelectorTestTypes.Test") + IEnumerable types = typeof(ClassToExploreUnwrappedTaskTypes) .Methods() .ReturnTypes() .UnwrapTaskTypes(); - // Assert types.Should() - // Void will be twice here - for void itself and for non-generic Task - .HaveCount(6) - .And.Contain(typeof(void)) + .HaveCount(4) .And.Contain(typeof(int)) - .And.Contain(typeof(bool)) - .And.Contain(typeof(List)) - .And.Contain(typeof(IEnumerable)); + .And.Contain(typeof(void)) + .And.Contain(typeof(string)) + .And.Contain(typeof(bool)); } [Fact] public void When_unwrap_enumerable_types_it_should_return_the_correct_types() { - // Arrange - Assembly assembly = typeof(ClassToExploreItsMethodsReturnValues).GetTypeInfo().Assembly; - - // Act - IEnumerable types = AllTypes.From(assembly) - .ThatAreInNamespace("Internal.UnwrapSelectorTestTypes.Test") + IEnumerable types = typeof(ClassToExploreUnwrappedEnumerableTypes) .Methods() .ReturnTypes() .UnwrapEnumerableTypes(); - // Assert types.Should() - .HaveCount(6) - .And.Contain(typeof(void)) + .HaveCount(4) + .And.Contain(typeof(IEnumerable)) + .And.Contain(typeof(bool)) .And.Contain(typeof(int)) - .And.Contain(typeof(Task)) - .And.Contain(typeof(Task)) - .And.Contain(typeof(string)) - .And.Contain(typeof(long)); + .And.Contain(typeof(string)); } } } @@ -655,9 +640,11 @@ namespace Internal.NotOnlyClasses.Test internal class NotOnlyClassesClass { } + internal enum NotOnlyClassesEnumeration { } + internal interface INotOnlyClassesInterface { } @@ -668,6 +655,7 @@ namespace Internal.StaticAndNonStaticClasses.Test internal static class StaticClass { } + internal class NotAStaticClass { } @@ -675,15 +663,31 @@ internal class NotAStaticClass namespace Internal.UnwrapSelectorTestTypes.Test { - internal class ClassToExploreItsMethodsReturnValues + internal class ClassToExploreUnwrappedTaskTypes { - internal void Do() { } internal int DoWithInt() { return default; } internal Task DoWithTask() { return Task.CompletedTask; } - internal Task DoWithTaskBoolean() { return Task.FromResult(true); } - internal List DoWithListOfString() { return default; } - internal IEnumerable DoWithEnumerableOfBooleans() { return default; } - + internal Task DoWithIntTask() { return Task.FromResult(string.Empty); } + internal ValueTask DoWithBoolValueTask() { return new ValueTask(false); } + } + + internal class ClassToExploreUnwrappedEnumerableTypes + { + internal IEnumerable DoWithTask() { return default; } + internal List DoWithIntTask() { return default; } + internal ClassImplementingMultipleEnumerable DoWithBoolValueTask() { return default; } + } + + internal class ClassImplementingMultipleEnumerable : IEnumerable, IEnumerable + { + private readonly IEnumerable integers = new int[0]; + private readonly IEnumerable strings = new string[0]; + + public IEnumerator GetEnumerator() => integers.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)integers).GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => strings.GetEnumerator(); } } diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index f3ebc70ca2..4524e19084 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -22,17 +22,12 @@ sidebar: * Added support for dictionary assertions on `IReadOnlyDictionary` - [#1298](https://github.com/fluentassertions/fluentassertions/pull/1298). * `GenericAsyncFunctionAssertions` now has `AndWhichConstraint` overloads for `NotThrow[Async]` and `NotThrowAfter[Async]` - [#1289](https://github.com/fluentassertions/fluentassertions/pull/1289). * Added `ReturnTypes` to `MethodInfoSelector` to get all return types from all the methods selected -* Added `Be` to `MethodInfoSelector` to check that methods have specified access modifier -* Added `NotBe` to `MethodInfoSelector` to check that methods doesn't have specified access modifier -* Added `ThatAreClasses` to `TypeSelector` -* Added `ThatAreNotClasses` to `TypeSelector` -* Added `ThatAreStaticClasses` to `TypeSelector` -* Added `ThatAreNotStaticClasses` to `TypeSelector` +* Added `[Not]Be` to `MethodInfoSelector` to check that methods [don't] have specified access modifier +* Added `ThatAre[Not]Classes`, `ThatAre[Not]Static` selectors to `TypeSelector` * Added `ThatAre` to `TypeSelector` to filter types with specified predicate * Added `UnwrapEnumerableTypes` to `TypeSelector` to get the `T` type from types implementing `IEnumerable` -* Added `UnwrapTaskTypes` to `TypeSelector` to get the `T` type for any type that are `Task` -* Added `BeSealed` to `TypeSelectorAssertions` -* Added `NotBeSealed` to `TypeSelectorAssertions` +* Added `UnwrapTaskTypes` to `TypeSelector` to get the `T` type for any type that are `Task` or `ValueTask` +* Added `[Not]BeSealed` to `TypeSelectorAssertions` **Fixes** * Reported actual value when it contained `{{{{` or `}}}}` - [#1234](https://github.com/fluentassertions/fluentassertions/pull/1234). From e9dff6839602dff93937d9f5f2e7a135da0bde34 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:09:07 +0200 Subject: [PATCH 15/27] Update Src/FluentAssertions/Types/TypeSelector.cs --- Src/FluentAssertions/Types/TypeSelector.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index 3cd3c9371a..2d07982dea 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -167,7 +167,7 @@ public TypeSelector ThatAreNotUnderNamespace(string @namespace) } /// - /// Determines whether the type is class + /// Determines whether the type is a class /// public TypeSelector ThatAreClasses() { From 91f31e81168b6299c6051324e836c819ea340b16 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:09:19 +0200 Subject: [PATCH 16/27] Update Src/FluentAssertions/Types/TypeSelectorAssertions.cs --- Src/FluentAssertions/Types/TypeSelectorAssertions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs index 749bfb7787..6c32b6f075 100644 --- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs @@ -293,7 +293,7 @@ public AndConstraint NotBeDecoratedWithOrInherit - /// Asserts that the all are sealed classes + /// Asserts that the selected types are sealed /// /// /// A formatted phrase as is supported by explaining why the assertion From a7e2763e6565148dd58a6085374b23cd99b20bd0 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:09:41 +0200 Subject: [PATCH 17/27] Update Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs --- Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index e32fdbbc55..35dff576f4 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -425,7 +425,7 @@ public void When_deselecting_a_prefix_of_a_namespace_it_should_not_match() public void When_selecting_types_that_are_classes_it_should_return_the_correct_types() { // Arrange - Assembly assembly = typeof(NotOnlyClassesClass).GetTypeInfo().Assembly; + Assembly assembly = typeof(NotOnlyClassesClass).GetType().Assembly; // Act IEnumerable types = AllTypes.From(assembly) From 11d4955d24d26329882f29a720ba4ba4039f9d60 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:09:55 +0200 Subject: [PATCH 18/27] Update Src/FluentAssertions/Types/TypeSelector.cs --- Src/FluentAssertions/Types/TypeSelector.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index 2d07982dea..c481f3d00f 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -193,7 +193,7 @@ public TypeSelector ThatAreStatic() } /// - /// Determines whether the type is not a static class + /// Determines whether the type is not static /// public TypeSelector ThatAreNotStatic() { From a935006ec0e60def368d3c1a0844b261a319dfa9 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:10:16 +0200 Subject: [PATCH 19/27] Update Src/FluentAssertions/Types/TypeSelector.cs --- Src/FluentAssertions/Types/TypeSelector.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index c481f3d00f..721b12f3e9 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -184,7 +184,7 @@ public TypeSelector ThatAreNotClasses() } /// - /// Determines whether the type is a static class + /// Determines whether the type is static /// public TypeSelector ThatAreStatic() { From dcb7b43d143a2dd60b20923decea213bdf7481b0 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:10:32 +0200 Subject: [PATCH 20/27] Update Src/FluentAssertions/TypeEnumerableExtensions.cs --- Src/FluentAssertions/TypeEnumerableExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index d44a00ab08..127d7fe443 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -94,7 +94,7 @@ public static IEnumerable ThatAreNotClasses(this IEnumerable types) return new TypeSelector(types).ThatAreNotClasses(); } /// - /// Filters to only include types that are static classes. + /// Filters to only include types that are static. /// public static IEnumerable ThatAreStatic(this IEnumerable types) { From d147ff4307c7c919e466edb6c5b3c9e82631e297 Mon Sep 17 00:00:00 2001 From: Jonas Nyrup Date: Sun, 26 Apr 2020 20:10:42 +0200 Subject: [PATCH 21/27] Update Src/FluentAssertions/TypeEnumerableExtensions.cs --- Src/FluentAssertions/TypeEnumerableExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index 127d7fe443..6592b3e7f7 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -102,7 +102,7 @@ public static IEnumerable ThatAreStatic(this IEnumerable types) } /// - /// Filters to only include types that are not static classes. + /// Filters to only include types that are not static. /// public static IEnumerable ThatAreNotStatic(this IEnumerable types) { From 897d8f4dae84d7abe5b84b75ca5f4d5bb56908c3 Mon Sep 17 00:00:00 2001 From: Fedor Shchudlo Date: Mon, 27 Apr 2020 08:01:33 +0400 Subject: [PATCH 22/27] Update Src/FluentAssertions/TypeEnumerableExtensions.cs Co-Authored-By: Jonas Nyrup --- Src/FluentAssertions/TypeEnumerableExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index 6592b3e7f7..a33c5dd7b1 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -118,7 +118,7 @@ public static IEnumerable ThatAre(this IEnumerable types, Func - /// Returns T for the types which are Task<T> or ValueTask<T>; the type itself otherwise + /// Returns T for the types which are or ; the type itself otherwise /// public static IEnumerable UnwrapTaskTypes(this IEnumerable types) { From 0cdae021b543b93c134fe933cd0eef81e30de068 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Mon, 27 Apr 2020 08:22:55 +0400 Subject: [PATCH 23/27] Fix of PR Comments --- Src/FluentAssertions/TypeEnumerableExtensions.cs | 7 ++++--- Src/FluentAssertions/Types/TypeSelector.cs | 7 ++++--- Src/FluentAssertions/Types/TypeSelectorAssertions.cs | 1 + .../TypeEnumerableExtensionsSpecs.cs | 1 + .../Types/MethodInfoAssertionSpecs.cs | 1 + .../FluentAssertions.Specs/Types/TypeSelectorSpecs.cs | 10 +++------- 6 files changed, 14 insertions(+), 13 deletions(-) diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index a33c5dd7b1..6993ac745c 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -1,6 +1,6 @@ using System; using System.Collections.Generic; - +using System.Threading.Tasks; using FluentAssertions.Types; namespace FluentAssertions @@ -93,6 +93,7 @@ public static IEnumerable ThatAreNotClasses(this IEnumerable types) { return new TypeSelector(types).ThatAreNotClasses(); } + /// /// Filters to only include types that are static. /// @@ -118,7 +119,7 @@ public static IEnumerable ThatAre(this IEnumerable types, Func - /// Returns T for the types which are or ; the type itself otherwise + /// Returns T for the types which are or ; the type itself otherwise /// public static IEnumerable UnwrapTaskTypes(this IEnumerable types) { @@ -126,7 +127,7 @@ public static IEnumerable UnwrapTaskTypes(this IEnumerable types) } /// - /// Returns T for the types which are IEnumerable<T> or implement the IEnumerable<T>; the type itself otherwise + /// Returns T for the types which are or implement the ; the type itself otherwise /// public static IEnumerable UnwrapEnumerableTypes(this IEnumerable types) { diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index 721b12f3e9..f6c0d48f82 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -174,6 +174,7 @@ public TypeSelector ThatAreClasses() types = types.Where(t => t.IsClass).ToList(); return this; } + /// /// Determines whether the type is not a class /// @@ -211,7 +212,7 @@ public TypeSelector ThatAre(Func predicate) } /// - /// Returns T for the types which are Task<T> or ValueTask<T>; the type itself otherwise + /// Returns T for the types which are or ; the type itself otherwise /// public TypeSelector UnwrapTaskTypes() { @@ -225,14 +226,14 @@ public TypeSelector UnwrapTaskTypes() { return type.GetGenericArguments().Single(); } - return type == typeof(Task) ? typeof(void) : type; + return type == typeof(Task) || type == typeof(ValueTask) ? typeof(void) : type; }).ToList(); return this; } /// - /// Returns T for the types which are IEnumerable<T> or implement the IEnumerable<T>; the type itself otherwise + /// Returns T for the types which are or implement the ; the type itself otherwise /// public TypeSelector UnwrapEnumerableTypes() { diff --git a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs index 6c32b6f075..85a756359a 100644 --- a/Src/FluentAssertions/Types/TypeSelectorAssertions.cs +++ b/Src/FluentAssertions/Types/TypeSelectorAssertions.cs @@ -333,6 +333,7 @@ public AndConstraint NotBeSealed(string because = "", pa return new AndConstraint(this); } + private static string GetDescriptionsFor(IEnumerable types) { string[] descriptions = types.Select(GetDescriptionFor).ToArray(); diff --git a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs index 6d87a5db52..d85c3add27 100644 --- a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs +++ b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs @@ -192,6 +192,7 @@ internal class BaseNamespaceClass } } + namespace TypeEnumerableExtensionsSpecs.BaseNamespace.Nested { internal class NestedNamespaceClass diff --git a/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs b/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs index 61aac39956..51668538dc 100644 --- a/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/MethodInfoAssertionSpecs.cs @@ -657,6 +657,7 @@ public void DoNothingWithParameter(int i) { } } + internal class ClassWithNonPublicMethods { protected void PublicDoNothing() diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index 35dff576f4..171cdc2238 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -507,8 +507,7 @@ public void When_selecting_types_with_predicate_it_should_return_the_correct_typ .And.Contain(typeof(ClassWithSomeAttributeDerived)) .And.Contain(typeof(ClassWithSomeAttributeThatImplementsSomeInterface)); } - - + [Fact] public void When_unwrap_task_types_it_should_return_the_correct_types() { @@ -518,11 +517,7 @@ public void When_unwrap_task_types_it_should_return_the_correct_types() .UnwrapTaskTypes(); types.Should() - .HaveCount(4) - .And.Contain(typeof(int)) - .And.Contain(typeof(void)) - .And.Contain(typeof(string)) - .And.Contain(typeof(bool)); + .BeEquivalentTo(typeof(int), typeof(void), typeof(void), typeof(string), typeof(bool)); } [Fact] @@ -667,6 +662,7 @@ internal class ClassToExploreUnwrappedTaskTypes { internal int DoWithInt() { return default; } internal Task DoWithTask() { return Task.CompletedTask; } + internal ValueTask DoWithValueTask() { return new ValueTask(); } internal Task DoWithIntTask() { return Task.FromResult(string.Empty); } internal ValueTask DoWithBoolValueTask() { return new ValueTask(false); } } From e75620daa3d4f11e0cb87af00a31d2a7f2037560 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Mon, 27 Apr 2020 08:30:58 +0400 Subject: [PATCH 24/27] Fix PR Comments --- .../Types/PropertyInfoSelector.cs | 11 + .../FluentAssertions/net47.approved.txt | 2220 ----------------- .../netcoreapp2.1.approved.txt | 2220 ----------------- .../netcoreapp3.0.approved.txt | 2220 ----------------- .../netstandard2.0.approved.txt | 2176 ---------------- .../netstandard2.1.approved.txt | 2220 ----------------- .../Types/PropertyInfoSelectorSpecs.cs | 14 + 7 files changed, 25 insertions(+), 11056 deletions(-) delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt diff --git a/Src/FluentAssertions/Types/PropertyInfoSelector.cs b/Src/FluentAssertions/Types/PropertyInfoSelector.cs index f46e342f9c..db0def8229 100644 --- a/Src/FluentAssertions/Types/PropertyInfoSelector.cs +++ b/Src/FluentAssertions/Types/PropertyInfoSelector.cs @@ -108,6 +108,17 @@ public PropertyInfoSelector NotOfType() return this; } + /// + /// Select return types of the properties + /// + /// + public TypeSelector ReturnTypes() + { + var returnTypes = selectedProperties.Select(mi => mi.PropertyType); + + return new TypeSelector(returnTypes); + } + /// /// The resulting objects. /// diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt deleted file mode 100644 index b279723ba5..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt +++ /dev/null @@ -1,2220 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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.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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt deleted file mode 100644 index e238cb80ce..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt +++ /dev/null @@ -1,2220 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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.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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt deleted file mode 100644 index 18ebd24a25..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt +++ /dev/null @@ -1,2220 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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.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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt deleted file mode 100644 index 2430ef694c..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt +++ /dev/null @@ -1,2176 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -namespace FluentAssertions.Events -{ - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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.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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt deleted file mode 100644 index 4a8f660bda..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt +++ /dev/null @@ -1,2220 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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.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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorSpecs.cs index cdf62e7d55..8d5b290460 100644 --- a/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/PropertyInfoSelectorSpecs.cs @@ -217,6 +217,20 @@ public void When_selecting_properties_not_decorated_with_or_inheriting_a_noninhe // Assert properties.Should().ContainSingle(); } + + [Fact] + public void When_selecting_properties_return_types_it_should_return_the_correct_types() + { + // Arrange + Type type = typeof(TestClassForPropertySelector); + + // Act + IEnumerable returnTypes = type.Properties().ReturnTypes().ToArray(); + + // Assert + returnTypes.Should() + .BeEquivalentTo(typeof(string), typeof(string), typeof(int), typeof(int), typeof(int), typeof(int)); + } } #region Internal classes used in unit tests From 8aac3acae626d3810f5075a53d8c23ca0cc37ff0 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Mon, 27 Apr 2020 08:45:35 +0400 Subject: [PATCH 25/27] Fix the tests --- .../FluentAssertions/net47.approved.txt | 2221 +++++++++++++++++ .../netcoreapp2.1.approved.txt | 2221 +++++++++++++++++ .../netcoreapp3.0.approved.txt | 2221 +++++++++++++++++ .../netstandard2.0.approved.txt | 2177 ++++++++++++++++ .../netstandard2.1.approved.txt | 2221 +++++++++++++++++ .../Types/TypeSelectorSpecs.cs | 8 +- 6 files changed, 11064 insertions(+), 5 deletions(-) create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt new file mode 100644 index 0000000000..783c157505 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 ThatAre(System.Func predicate) { } + 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt new file mode 100644 index 0000000000..211cc0a315 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 ThatAre(System.Func predicate) { } + 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt new file mode 100644 index 0000000000..cb0e9f321b --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 ThatAre(System.Func predicate) { } + 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt new file mode 100644 index 0000000000..ab8ceb047e --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt @@ -0,0 +1,2177 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +namespace FluentAssertions.Events +{ + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 ThatAre(System.Func predicate) { } + 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt new file mode 100644 index 0000000000..436d0f2db6 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } + 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 ThatAre(System.Func predicate) { } + 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index 171cdc2238..81f87fe3f5 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -425,15 +425,13 @@ public void When_deselecting_a_prefix_of_a_namespace_it_should_not_match() public void When_selecting_types_that_are_classes_it_should_return_the_correct_types() { // Arrange - Assembly assembly = typeof(NotOnlyClassesClass).GetType().Assembly; + TypeSelector types = new[] { typeof(NotOnlyClassesClass), typeof(NotOnlyClassesEnumeration), typeof(INotOnlyClassesInterface) }.Types(); // Act - IEnumerable types = AllTypes.From(assembly) - .ThatAreInNamespace("Internal.NotOnlyClasses.Test") - .ThatAreClasses(); + IEnumerable filteredTypes = types.ThatAreClasses(); // Assert - types.Should() + filteredTypes.Should() .ContainSingle() .Which.Should().Be(typeof(NotOnlyClassesClass)); } From ca3a24e440856872bc5ba0ad991e4c43caa1fac3 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Mon, 27 Apr 2020 17:25:16 +0400 Subject: [PATCH 26/27] Fix PR comment --- .../TypeEnumerableExtensions.cs | 4 +- Src/FluentAssertions/Types/TypeSelector.cs | 2 +- .../FluentAssertions/net47.approved.txt | 2221 ----------------- .../netcoreapp2.1.approved.txt | 2221 ----------------- .../netcoreapp3.0.approved.txt | 2221 ----------------- .../netstandard2.0.approved.txt | 2177 ---------------- .../netstandard2.1.approved.txt | 2221 ----------------- .../TypeEnumerableExtensionsSpecs.cs | 2 +- .../Types/TypeSelectorSpecs.cs | 2 +- docs/_pages/releases.md | 2 +- 10 files changed, 6 insertions(+), 11067 deletions(-) delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt delete mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt diff --git a/Src/FluentAssertions/TypeEnumerableExtensions.cs b/Src/FluentAssertions/TypeEnumerableExtensions.cs index 6993ac745c..8f085896a2 100644 --- a/Src/FluentAssertions/TypeEnumerableExtensions.cs +++ b/Src/FluentAssertions/TypeEnumerableExtensions.cs @@ -113,9 +113,9 @@ public static IEnumerable ThatAreNotStatic(this IEnumerable types) /// /// Filters to only include types that satisfies the passed. /// - public static IEnumerable ThatAre(this IEnumerable types, Func predicate) + public static IEnumerable ThatSatisfy(this IEnumerable types, Func predicate) { - return new TypeSelector(types).ThatAre(predicate); + return new TypeSelector(types).ThatSatisfy(predicate); } /// diff --git a/Src/FluentAssertions/Types/TypeSelector.cs b/Src/FluentAssertions/Types/TypeSelector.cs index f6c0d48f82..39581c599c 100644 --- a/Src/FluentAssertions/Types/TypeSelector.cs +++ b/Src/FluentAssertions/Types/TypeSelector.cs @@ -205,7 +205,7 @@ public TypeSelector ThatAreNotStatic() /// /// Allows to filter the types with the passed /// - public TypeSelector ThatAre(Func predicate) + public TypeSelector ThatSatisfy(Func predicate) { types = types.Where(predicate).ToList(); return this; diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt deleted file mode 100644 index 783c157505..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt +++ /dev/null @@ -1,2221 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt deleted file mode 100644 index 211cc0a315..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt +++ /dev/null @@ -1,2221 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt deleted file mode 100644 index cb0e9f321b..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt +++ /dev/null @@ -1,2221 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt deleted file mode 100644 index ab8ceb047e..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt +++ /dev/null @@ -1,2177 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -namespace FluentAssertions.Events -{ - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt deleted file mode 100644 index 436d0f2db6..0000000000 --- a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt +++ /dev/null @@ -1,2221 +0,0 @@ -[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } - public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } - public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } - 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) { } - public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } - public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } - public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } - 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } - 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) { } - 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) - where TException : System.Exception { } - } - public static class AssertionOptions - { - public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } - public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } - public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } - } - 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; - public static string DetermineCallerIdentity() { } - } - [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] - public class CustomAssertionAttribute : System.Attribute - { - public CustomAssertionAttribute() { } - } - public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable - { - public EquivalencyStepCollection() { } - 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } - public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } - public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 ThatAre(this System.Collections.Generic.IEnumerable types, System.Func predicate) { } - 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions - where TSubject : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.CollectionAssertions - { - protected CollectionAssertions(TSubject subject) { } - 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint Equal(params object[] elements) { } - public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } - } - 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.Collections.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions - { - public GenericCollectionAssertions(TCollection actualValue) { } - 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } - public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) - where TKey : class { } - public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } - } - 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } - } - public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.IEnumerable - where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions - { - public NonGenericCollectionAssertions(TCollection collection) { } - public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> - { - public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } - } - public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions - { - public SelfReferencingCollectionAssertions(TCollection actualValue) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } - 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } - 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } - } - 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.SelfReferencingCollectionAssertions - where TCollection : System.Collections.Generic.IEnumerable - where TAssertions : FluentAssertions.Collections.StringCollectionAssertions - { - public StringCollectionAssertions(TCollection actualValue) { } - 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } - public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } - public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } - } - public class WhichValueConstraint : FluentAssertions.AndConstraint - where TCollection : System.Collections.Generic.IEnumerable> - where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions - { - public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } - public TValue WhichValue { get; } - } -} -namespace FluentAssertions.Common -{ - public enum CSharpAccessModifier - { - Public = 0, - Private = 1, - Protected = 2, - Internal = 3, - ProtectedInternal = 4, - InvalidForCSharp = 5, - PrivateProtected = 6, - } - public static class CSharpAccessModifierExtensions { } - 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(); - bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); - } - public interface IConfigurationStore - { - string GetSetting(string name); - } - public interface IReflector - { - System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); - } - public interface ITimer - { - System.TimeSpan Elapsed { get; } - } - public static class MethodInfoExtensions { } - public static class ObjectExtensions - { - public static bool IsSameOrEqualTo(this object actual, object expected) { } - } - public static class PropertyInfoExtensions { } - 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 static class TypeExtensions - { - public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } - public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } - public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } - public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } - public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } - public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } - public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } - public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } - public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } - public static bool HasParameterlessMethod(this System.Type type, string methodName) { } - public static bool HasValueSemantics(this System.Type type) { } - public static bool Implements(this System.Type type, System.Type expectedBaseType) { } - public static bool IsCSharpAbstract(this System.Type type) { } - public static bool IsCSharpSealed(this System.Type type) { } - public static bool IsCSharpStatic(this System.Type type) { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) - where TAttribute : System.Attribute { } - public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } - public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } - public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } - public static bool OverridesEquals(this System.Type type) { } - } - public enum ValueFormatterDetectionMode - { - Disabled = 0, - Specific = 1, - Scan = 2, - } -} -namespace FluentAssertions.Equivalency -{ - public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public AutoConversionStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - 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.IMemberInfo info) { } - public override string ToString() { } - } - public enum CyclicReferenceHandling - { - Ignore = 0, - ThrowException = 1, - } - public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public DictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumEqualityStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public enum EnumEquivalencyHandling - { - ByValue = 0, - ByName = 1, - } - public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public override string ToString() { } - } - 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } - public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } - } - public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo - { - public EquivalencyValidationContext() { } - public string Because { get; set; } - public object[] BecauseArgs { get; set; } - public System.Type CompileTimeType { get; set; } - public object Expectation { get; set; } - public bool IsRoot { get; } - public bool RootIsCollection { get; set; } - public System.Type RuntimeType { get; } - public string SelectedMemberDescription { get; set; } - public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } - public string SelectedMemberPath { get; set; } - public object Subject { get; set; } - public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - public override string ToString() { } - public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } - } - public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator - { - public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } - public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } - } - public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericDictionaryEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public GenericEnumerableEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public delegate string GetTraceMessage(string path); - public interface IAssertionContext - { - string Because { get; set; } - object[] BecauseArgs { get; set; } - TSubject Expectation { get; } - TSubject Subject { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } - } - public interface IEquivalencyAssertionOptions - { - bool AllowInfiniteRecursion { get; } - FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } - FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } - bool IncludeFields { get; } - bool IncludeProperties { get; } - bool IsRecursive { get; } - System.Collections.Generic.IEnumerable MatchingRules { get; } - FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } - System.Collections.Generic.IEnumerable SelectionRules { get; } - FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - bool UseRuntimeTyping { get; } - System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } - FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); - } - public interface IEquivalencyStep - { - bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo - { - string Because { get; } - object[] BecauseArgs { get; } - object Expectation { get; } - bool IsRoot { get; } - bool RootIsCollection { get; set; } - object Subject { get; set; } - FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } - System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); - void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); - } - public interface IEquivalencyValidator - { - void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); - } - public interface IMemberInfo - { - System.Type CompileTimeType { get; } - System.Type RuntimeType { get; } - string SelectedMemberDescription { get; } - FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } - string SelectedMemberPath { get; } - } - public interface IMemberMatchingRule - { - FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IMemberSelectionRule - { - bool IncludesMembers { get; } - System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); - } - public interface IOrderingRule - { - FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); - } - public interface ITraceWriter - { - System.IDisposable AddBlock(string trace); - void AddSingle(string trace); - string ToString(); - } - 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.IMemberInfo memberInfo) { } - } - public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ReferenceEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public RunAllUserStepsEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public abstract class SelectedMemberInfo - { - protected SelectedMemberInfo() { } - public abstract System.Type DeclaringType { get; } - public abstract System.Type MemberType { get; } - public abstract string Name { get; } - public abstract object GetValue(object obj, object[] index); - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } - public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } - } - public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions - where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions - { - [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] - protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; - protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } - public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } - public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } - protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } - public TSelf AllowingInfiniteRecursion() { } - public TSelf ComparingByMembers() { } - public TSelf ComparingByValue() { } - public TSelf ComparingEnumsByName() { } - public TSelf ComparingEnumsByValue() { } - 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 IncludingAllDeclaredProperties() { } - public TSelf IncludingAllRuntimeProperties() { } - public TSelf IncludingFields() { } - 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 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.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() { } - } - } - public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public SimpleEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter - { - public StringBuilderTraceWriter() { } - public System.IDisposable AddBlock(string trace) { } - public void AddSingle(string trace) { } - public override string ToString() { } - } - public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StringEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public StructuralEqualityEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } - 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) { } - } - public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep - { - public ValueTypeEquivalencyStep() { } - public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } - } -} -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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } - public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } - public System.Type EventHandlerType { get; } - public string EventName { get; } - public object EventObject { get; } - public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } - public void Dispose() { } - public System.Collections.Generic.IEnumerator GetEnumerator() { } - public void RecordEvent(params object[] parameters) { } - public void Reset() { } - } - public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable - { - System.Type EventHandlerType { get; } - string EventName { get; } - object EventObject { get; } - void RecordEvent(params object[] parameters); - void Reset(); - } - public interface IMonitor : System.IDisposable - { - FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } - FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } - T Subject { get; } - void Clear(); - FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } - } - public class RecordedEvent - { - public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } - public System.Collections.Generic.IEnumerable Parameters { get; } - public System.DateTime TimestampUtc { get; set; } - } -} -namespace FluentAssertions.Execution -{ - public class AssertionFailedException : System.Exception - { - public AssertionFailedException(string message) { } - protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } - } - public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public AssertionScope() { } - public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } - public AssertionScope(string context) { } - public string Context { get; set; } - public bool Succeeded { 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, string value) { } - 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, params object[] args) { } - public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } - 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } - public bool SourceSucceeded { get; } - public FluentAssertions.Execution.IAssertionScope Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } - } - public class ContinuationOfGiven - { - public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } - public FluentAssertions.Execution.GivenSelector Then { get; } - public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } - } - public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable - { - public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } - public bool Succeeded { get; } - 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } - 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 - { - bool Succeeded { get; } - 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, 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(); - } -} -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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter - { - public AttributeBasedFormatter() { } - public System.Reflection.MethodInfo[] Formatters { get; } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DateTimeOffsetValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DecimalValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } - protected virtual string TypeDisplayName(System.Type type) { } - } - public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public DoubleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExceptionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public ExpressionValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public delegate string FormatChild(string childPath, object value); - 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, bool useLineBreaks = false) { } - } - public class FormattingContext - { - public FormattingContext() { } - public int Depth { get; set; } - public bool UseLineBreaks { get; set; } - } - public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public GuidValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public interface IValueFormatter - { - bool CanHandle(object value); - string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); - } - public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public Int64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter - { - public MultidimensionalArrayFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public NullValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter - { - public PropertyInfoFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SByteValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public SingleValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public StringValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TaskFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public TimeSpanValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt16ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt32ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public UInt64ValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XDocumentValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } - public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XElementValueFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, 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 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 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 T? Subject { get; } - 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions - { - public ObjectAssertions(object value) { } - protected override string Identifier { get; } - public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } - public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - protected override void InvokeSubject() { } - 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> - 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) { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } - public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) - where TException : System.Exception { } - protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } - protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } - public ExecutionTime(System.Func action) { } - protected ExecutionTime(System.Action action, string actionDescription) { } - protected ExecutionTime(System.Func action, string actionDescription) { } - } - 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } - public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } - } - 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) { } - } -} -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 ThatAreDecoratedWith() - where TAttribute : System.Attribute { } - public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() - where TAttribute : System.Attribute { } - 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 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 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 ThatAre(System.Func predicate) { } - 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } - public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } - } - public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter - { - public XmlNodeFormatter() { } - public bool CanHandle(object value) { } - public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } - } -} \ No newline at end of file diff --git a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs index d85c3add27..0751a81e95 100644 --- a/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs +++ b/Tests/FluentAssertions.Specs/TypeEnumerableExtensionsSpecs.cs @@ -151,7 +151,7 @@ public void When_selecting_types_with_predicate_it_should_return_the_correct_typ { var types = new[] { typeof(JustAClass), typeof(AStaticClass) }; - types.ThatAre(t => t.IsCSharpStatic()) + types.ThatSatisfy(t => t.IsCSharpStatic()) .Should() .ContainSingle() .Which.Should().Be(typeof(AStaticClass)); diff --git a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs index 81f87fe3f5..a25ffc2bbc 100644 --- a/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs +++ b/Tests/FluentAssertions.Specs/Types/TypeSelectorSpecs.cs @@ -496,7 +496,7 @@ public void When_selecting_types_with_predicate_it_should_return_the_correct_typ // Act IEnumerable types = AllTypes.From(assembly) - .ThatAre(t => t.GetCustomAttribute() != null); + .ThatSatisfy(t => t.GetCustomAttribute() != null); // Assert types.Should() diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md index 12c1596799..bcbe4fc478 100644 --- a/docs/_pages/releases.md +++ b/docs/_pages/releases.md @@ -24,7 +24,7 @@ sidebar: * Added `ReturnTypes` to `MethodInfoSelector` to get all return types from all the methods selected * Added `[Not]Be` to `MethodInfoSelector` to check that methods [don't] have specified access modifier * Added `ThatAre[Not]Classes`, `ThatAre[Not]Static` selectors to `TypeSelector` -* Added `ThatAre` to `TypeSelector` to filter types with specified predicate +* Added `ThatSatisfy` to `TypeSelector` to filter types with specified predicate * Added `UnwrapEnumerableTypes` to `TypeSelector` to get the `T` type from types implementing `IEnumerable` * Added `UnwrapTaskTypes` to `TypeSelector` to get the `T` type for any type that are `Task` or `ValueTask` * Added `[Not]BeSealed` to `TypeSelectorAssertions` From ab08de2df319bb375148f76825aa672d84f67356 Mon Sep 17 00:00:00 2001 From: "f.shchudlo" Date: Mon, 27 Apr 2020 17:30:49 +0400 Subject: [PATCH 27/27] Update approval files --- .../FluentAssertions/net47.approved.txt | 2221 +++++++++++++++++ .../netcoreapp2.1.approved.txt | 2221 +++++++++++++++++ .../netcoreapp3.0.approved.txt | 2221 +++++++++++++++++ .../netstandard2.0.approved.txt | 2177 ++++++++++++++++ .../netstandard2.1.approved.txt | 2221 +++++++++++++++++ 5 files changed, 11061 insertions(+) create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt create mode 100644 Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt new file mode 100644 index 0000000000..ee2d22fe62 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt new file mode 100644 index 0000000000..d0ec54f309 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt new file mode 100644 index 0000000000..98dc19f1b7 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt new file mode 100644 index 0000000000..b7d3433640 --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.approved.txt @@ -0,0 +1,2177 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +namespace FluentAssertions.Events +{ + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt new file mode 100644 index 0000000000..668325ea1d --- /dev/null +++ b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.approved.txt @@ -0,0 +1,2221 @@ +[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 FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Action action) { } + public static FluentAssertions.Specialized.ExecutionTime ExecutionTime(this System.Func action) { } + public static FluentAssertions.Specialized.MemberExecutionTime ExecutionTimeOf(this T subject, System.Linq.Expressions.Expression> action) { } + 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) { } + public static FluentAssertions.Types.MethodInfoSelectorAssertions Should(this FluentAssertions.Types.MethodInfoSelector methodSelector) { } + public static FluentAssertions.Types.PropertyInfoSelectorAssertions Should(this FluentAssertions.Types.PropertyInfoSelector propertyInfoSelector) { } + public static FluentAssertions.Types.TypeSelectorAssertions Should(this FluentAssertions.Types.TypeSelector typeSelector) { } + 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.Collections.NonGenericCollectionAssertions Should(this System.Collections.IEnumerable 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.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) { } + 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) { } + 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 System.Threading.Tasks.Task> WithMessage(this System.Threading.Tasks.Task> task, string expectedWildcardPattern, string because = "", params object[] becauseArgs) + where TException : System.Exception { } + } + public static class AssertionOptions + { + public static FluentAssertions.EquivalencyStepCollection EquivalencySteps { get; } + public static void AssertEquivalencyUsing(System.Func defaultsConfigurer) { } + public static FluentAssertions.Equivalency.EquivalencyAssertionOptions CloneDefaults() { } + } + 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; + public static string DetermineCallerIdentity() { } + } + [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.All, AllowMultiple=false)] + public class CustomAssertionAttribute : System.Attribute + { + public CustomAssertionAttribute() { } + } + public class EquivalencyStepCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + public EquivalencyStepCollection() { } + 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.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, params System.Linq.Expressions.Expression<>[] predicates) { } + public static FluentAssertions.Events.IEventRecorder WithArgs(this FluentAssertions.Events.IEventRecorder eventRecorder, System.Linq.Expressions.Expression> predicate) { } + public static FluentAssertions.Events.IEventRecorder WithSender(this FluentAssertions.Events.IEventRecorder eventRecorder, 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 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 abstract class CollectionAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions + where TSubject : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.CollectionAssertions + { + protected CollectionAssertions(TSubject subject) { } + 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 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 AssertCollectionEndsWith(System.Collections.Generic.IEnumerable actual, TExpected[] 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 AssertCollectionStartsWith(System.Collections.Generic.IEnumerable actualItems, TExpected[] expected, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + protected void AssertSubjectEquality(System.Collections.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(params object[] expectations) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeEquivalentTo(System.Collections.IEnumerable expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, 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 BeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(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.IEnumerable expectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Contain(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainEquivalentOf(TExpectation expectation, System.Func, FluentAssertions.Equivalency.EquivalencyAssertionOptions> config, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params object[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainItemsAssignableTo(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint EndWith(object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint Equal(params object[] elements) { } + public FluentAssertions.AndConstraint Equal(System.Collections.IEnumerable expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint HaveElementAt(int index, object element, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementPreceding(object successor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveElementSucceeding(object predecessor, object expectation, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint IntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Collections.IEnumerable unexpected, 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 NotBeInDescendingOrder(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(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.IEnumerable unexpectedSuperset, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.IEnumerable 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 NotContainNulls(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotEqual(System.Collections.IEnumerable unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveSameCount(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotIntersectWith(System.Collections.IEnumerable otherCollection, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint StartWith(object element, string because = "", params object[] becauseArgs) { } + } + 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.Collections.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.GenericCollectionAssertions + { + public GenericCollectionAssertions(TCollection actualValue) { } + 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 BeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint BeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInAscendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotBeInDescendingOrder(System.Linq.Expressions.Expression> propertyExpression, System.Collections.Generic.IComparer comparer, string because = "", params object[] args) { } + public FluentAssertions.AndConstraint NotContainNulls(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) + where TKey : class { } + public FluentAssertions.AndConstraint OnlyHaveUniqueItems(System.Linq.Expressions.Expression> predicate, string because = "", params object[] becauseArgs) { } + } + 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.WhichValueConstraint 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 NonGenericCollectionAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(System.Collections.IEnumerable collection) { } + } + public class NonGenericCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.IEnumerable + where TAssertions : FluentAssertions.Collections.NonGenericCollectionAssertions + { + public NonGenericCollectionAssertions(TCollection collection) { } + public FluentAssertions.AndConstraint Contain(object expected, 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(object unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions, T, TAssertions> + { + public SelfReferencingCollectionAssertions(System.Collections.Generic.IEnumerable actualValue) { } + } + public class SelfReferencingCollectionAssertions : FluentAssertions.Collections.CollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.SelfReferencingCollectionAssertions + { + public SelfReferencingCollectionAssertions(TCollection actualValue) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expectedItemsList, params T[] additionalExpectedItems) { } + 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 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(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 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 HaveCountLessOrEqualTo(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint HaveCountLessThan(int expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContain(System.Collections.Generic.IEnumerable unexpectedItemsList, params T[] additionalUnexpectedItems) { } + 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 NotHaveCount(int unexpected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint OnlyContain(System.Linq.Expressions.Expression> predicate, 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(System.Collections.Generic.IEnumerable expectation, System.Func equalityComparison, string because = "", params object[] becauseArgs) { } + } + 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.SelfReferencingCollectionAssertions + where TCollection : System.Collections.Generic.IEnumerable + where TAssertions : FluentAssertions.Collections.StringCollectionAssertions + { + public StringCollectionAssertions(TCollection actualValue) { } + 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.AndConstraint Contain(System.Collections.Generic.IEnumerable expected) { } + public FluentAssertions.AndConstraint Contain(System.Collections.Generic.IEnumerable expected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint ContainInOrder(params string[] expected) { } + public FluentAssertions.AndConstraint ContainInOrder(System.Collections.Generic.IEnumerable expected, 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 NotContain(System.Collections.Generic.IEnumerable unexpected, string because = null, object becauseArg = null, params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotContainMatch(string wildcardPattern, string because = "", params object[] becauseArgs) { } + } + public class WhichValueConstraint : FluentAssertions.AndConstraint + where TCollection : System.Collections.Generic.IEnumerable> + where TAssertions : FluentAssertions.Collections.GenericDictionaryAssertions + { + public WhichValueConstraint(TAssertions parentConstraint, TValue value) { } + public TValue WhichValue { get; } + } +} +namespace FluentAssertions.Common +{ + public enum CSharpAccessModifier + { + Public = 0, + Private = 1, + Protected = 2, + Internal = 3, + ProtectedInternal = 4, + InvalidForCSharp = 5, + PrivateProtected = 6, + } + public static class CSharpAccessModifierExtensions { } + 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(); + bool Wait(System.Threading.Tasks.Task task, System.TimeSpan timeout); + } + public interface IConfigurationStore + { + string GetSetting(string name); + } + public interface IReflector + { + System.Collections.Generic.IEnumerable GetAllTypesFromAppDomain(System.Func predicate); + } + public interface ITimer + { + System.TimeSpan Elapsed { get; } + } + public static class MethodInfoExtensions { } + public static class ObjectExtensions + { + public static bool IsSameOrEqualTo(this object actual, object expected) { } + } + public static class PropertyInfoExtensions { } + 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 static class TypeExtensions + { + public static System.Reflection.FieldInfo FindField(this System.Type type, string fieldName, System.Type preferredType) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo FindMember(this System.Type type, string memberName, System.Type preferredType) { } + public static System.Reflection.PropertyInfo FindProperty(this System.Type type, string propertyName, System.Type preferredType) { } + public static System.Reflection.ConstructorInfo GetConstructor(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetExplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.MethodInfo GetImplicitConversionOperator(this System.Type type, System.Type sourceType, System.Type targetType) { } + public static System.Reflection.PropertyInfo GetIndexerByParameterTypes(this System.Type type, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Reflection.MethodInfo GetMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateFields(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateMembers(this System.Type typeToReflect) { } + public static System.Collections.Generic.IEnumerable GetNonPrivateProperties(this System.Type typeToReflect, System.Collections.Generic.IEnumerable filter = null) { } + public static System.Reflection.MethodInfo GetParameterlessMethod(this System.Type type, string methodName) { } + public static System.Reflection.PropertyInfo GetPropertyByName(this System.Type type, string propertyName) { } + public static bool HasExplicitlyImplementedProperty(this System.Type type, System.Type interfaceType, string propertyName) { } + public static bool HasMethod(this System.Type type, string methodName, System.Collections.Generic.IEnumerable parameterTypes) { } + public static bool HasParameterlessMethod(this System.Type type, string methodName) { } + public static bool HasValueSemantics(this System.Type type) { } + public static bool Implements(this System.Type type, System.Type expectedBaseType) { } + public static bool IsCSharpAbstract(this System.Type type) { } + public static bool IsCSharpSealed(this System.Type type) { } + public static bool IsCSharpStatic(this System.Type type) { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWith(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.MemberInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Reflection.TypeInfo type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsDecoratedWithOrInherit(this System.Type type, System.Linq.Expressions.Expression> isMatchingAttributePredicate) + where TAttribute : System.Attribute { } + public static bool IsEquivalentTo(this FluentAssertions.Equivalency.SelectedMemberInfo property, FluentAssertions.Equivalency.SelectedMemberInfo otherProperty) { } + public static bool IsIndexer(this System.Reflection.PropertyInfo member) { } + public static bool IsSameOrInherits(this System.Type actualType, System.Type expectedType) { } + public static bool OverridesEquals(this System.Type type) { } + } + public enum ValueFormatterDetectionMode + { + Disabled = 0, + Specific = 1, + Scan = 2, + } +} +namespace FluentAssertions.Equivalency +{ + public class AssertionRuleEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AssertionRuleEquivalencyStep(System.Linq.Expressions.Expression> predicate, System.Action> assertion) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + public class AutoConversionStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public AutoConversionStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + 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.IMemberInfo info) { } + public override string ToString() { } + } + public enum CyclicReferenceHandling + { + Ignore = 0, + ThrowException = 1, + } + public class DictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public DictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EnumEqualityStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumEqualityStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public enum EnumEquivalencyHandling + { + ByValue = 0, + ByName = 1, + } + public class EnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class EqualityComparerEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public EqualityComparerEquivalencyStep(System.Collections.Generic.IEqualityComparer comparer) { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public override string ToString() { } + } + 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 FluentAssertions.Equivalency.EquivalencyAssertionOptions> AsCollection() { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Excluding(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> predicate) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions Including(System.Linq.Expressions.Expression> expression) { } + public FluentAssertions.Equivalency.EquivalencyAssertionOptions WithStrictOrderingFor(System.Linq.Expressions.Expression> expression) { } + } + public class EquivalencyValidationContext : FluentAssertions.Equivalency.IEquivalencyValidationContext, FluentAssertions.Equivalency.IMemberInfo + { + public EquivalencyValidationContext() { } + public string Because { get; set; } + public object[] BecauseArgs { get; set; } + public System.Type CompileTimeType { get; set; } + public object Expectation { get; set; } + public bool IsRoot { get; } + public bool RootIsCollection { get; set; } + public System.Type RuntimeType { get; } + public string SelectedMemberDescription { get; set; } + public FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; set; } + public string SelectedMemberPath { get; set; } + public object Subject { get; set; } + public FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + public override string ToString() { } + public System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + public void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getTraceMessage) { } + } + public class EquivalencyValidator : FluentAssertions.Equivalency.IEquivalencyValidator + { + public EquivalencyValidator(FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public void AssertEquality(FluentAssertions.Equivalency.EquivalencyValidationContext context) { } + public void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context) { } + } + public class GenericDictionaryEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericDictionaryEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class GenericEnumerableEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public GenericEnumerableEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public delegate string GetTraceMessage(string path); + public interface IAssertionContext + { + string Because { get; set; } + object[] BecauseArgs { get; set; } + TSubject Expectation { get; } + TSubject Subject { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SubjectProperty { get; } + } + public interface IEquivalencyAssertionOptions + { + bool AllowInfiniteRecursion { get; } + FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + FluentAssertions.Equivalency.CyclicReferenceHandling CyclicReferenceHandling { get; } + FluentAssertions.Equivalency.EnumEquivalencyHandling EnumEquivalencyHandling { get; } + bool IncludeFields { get; } + bool IncludeProperties { get; } + bool IsRecursive { get; } + System.Collections.Generic.IEnumerable MatchingRules { get; } + FluentAssertions.Equivalency.OrderingRuleCollection OrderingRules { get; } + System.Collections.Generic.IEnumerable SelectionRules { get; } + FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + bool UseRuntimeTyping { get; } + System.Collections.Generic.IEnumerable UserEquivalencySteps { get; } + FluentAssertions.Equivalency.EqualityStrategy GetEqualityStrategy(System.Type type); + } + public interface IEquivalencyStep + { + bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IEquivalencyValidationContext : FluentAssertions.Equivalency.IMemberInfo + { + string Because { get; } + object[] BecauseArgs { get; } + object Expectation { get; } + bool IsRoot { get; } + bool RootIsCollection { get; set; } + object Subject { get; set; } + FluentAssertions.Equivalency.ITraceWriter Tracer { get; set; } + System.IDisposable TraceBlock(FluentAssertions.Equivalency.GetTraceMessage getMessage); + void TraceSingle(FluentAssertions.Equivalency.GetTraceMessage getMessage); + } + public interface IEquivalencyValidator + { + void AssertEqualityUsing(FluentAssertions.Equivalency.IEquivalencyValidationContext context); + } + public interface IMemberInfo + { + System.Type CompileTimeType { get; } + System.Type RuntimeType { get; } + string SelectedMemberDescription { get; } + FluentAssertions.Equivalency.SelectedMemberInfo SelectedMemberInfo { get; } + string SelectedMemberPath { get; } + } + public interface IMemberMatchingRule + { + FluentAssertions.Equivalency.SelectedMemberInfo Match(FluentAssertions.Equivalency.SelectedMemberInfo expectedMember, object subject, string memberPath, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IMemberSelectionRule + { + bool IncludesMembers { get; } + System.Collections.Generic.IEnumerable SelectMembers(System.Collections.Generic.IEnumerable selectedMembers, FluentAssertions.Equivalency.IMemberInfo context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config); + } + public interface IOrderingRule + { + FluentAssertions.Equivalency.OrderStrictness Evaluate(FluentAssertions.Equivalency.IMemberInfo memberInfo); + } + public interface ITraceWriter + { + System.IDisposable AddBlock(string trace); + void AddSingle(string trace); + string ToString(); + } + 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.IMemberInfo memberInfo) { } + } + public class ReferenceEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ReferenceEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public virtual bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class RunAllUserStepsEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public RunAllUserStepsEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public abstract class SelectedMemberInfo + { + protected SelectedMemberInfo() { } + public abstract System.Type DeclaringType { get; } + public abstract System.Type MemberType { get; } + public abstract string Name { get; } + public abstract object GetValue(object obj, object[] index); + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.FieldInfo fieldInfo) { } + public static FluentAssertions.Equivalency.SelectedMemberInfo Create(System.Reflection.PropertyInfo propertyInfo) { } + } + public abstract class SelfReferenceEquivalencyAssertionOptions : FluentAssertions.Equivalency.IEquivalencyAssertionOptions + where TSelf : FluentAssertions.Equivalency.SelfReferenceEquivalencyAssertionOptions + { + [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] + protected readonly FluentAssertions.Equivalency.OrderingRuleCollection orderingRules; + protected SelfReferenceEquivalencyAssertionOptions(FluentAssertions.Equivalency.IEquivalencyAssertionOptions defaults) { } + public FluentAssertions.Equivalency.ConversionSelector ConversionSelector { get; } + public FluentAssertions.Equivalency.ITraceWriter TraceWriter { get; } + protected TSelf AddSelectionRule(FluentAssertions.Equivalency.IMemberSelectionRule selectionRule) { } + public TSelf AllowingInfiniteRecursion() { } + public TSelf ComparingByMembers() { } + public TSelf ComparingByValue() { } + public TSelf ComparingEnumsByName() { } + public TSelf ComparingEnumsByValue() { } + 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 IncludingAllDeclaredProperties() { } + public TSelf IncludingAllRuntimeProperties() { } + public TSelf IncludingFields() { } + 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 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.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() { } + } + } + public class SimpleEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public SimpleEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StringBuilderTraceWriter : FluentAssertions.Equivalency.ITraceWriter + { + public StringBuilderTraceWriter() { } + public System.IDisposable AddBlock(string trace) { } + public void AddSingle(string trace) { } + public override string ToString() { } + } + public class StringEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StringEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + public class StructuralEqualityEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public StructuralEqualityEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator parent, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } + 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) { } + } + public class ValueTypeEquivalencyStep : FluentAssertions.Equivalency.IEquivalencyStep + { + public ValueTypeEquivalencyStep() { } + public bool CanHandle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + public bool Handle(FluentAssertions.Equivalency.IEquivalencyValidationContext context, FluentAssertions.Equivalency.IEquivalencyValidator structuralEqualityValidator, FluentAssertions.Equivalency.IEquivalencyAssertionOptions config) { } + } +} +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.IEventRecorder Raise(string eventName, string because = "", params object[] becauseArgs) { } + public FluentAssertions.Events.IEventRecorder 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 class EventRecorder : FluentAssertions.Events.IEventRecorder, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + public EventRecorder(object eventRaiser, string eventName, System.Func utcNow) { } + public System.Type EventHandlerType { get; } + public string EventName { get; } + public object EventObject { get; } + public void Attach(System.WeakReference subject, System.Reflection.EventInfo eventInfo) { } + public void Dispose() { } + public System.Collections.Generic.IEnumerator GetEnumerator() { } + public void RecordEvent(params object[] parameters) { } + public void Reset() { } + } + public interface IEventRecorder : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable + { + System.Type EventHandlerType { get; } + string EventName { get; } + object EventObject { get; } + void RecordEvent(params object[] parameters); + void Reset(); + } + public interface IMonitor : System.IDisposable + { + FluentAssertions.Events.EventMetadata[] MonitoredEvents { get; } + FluentAssertions.Events.OccurredEvent[] OccurredEvents { get; } + T Subject { get; } + void Clear(); + FluentAssertions.Events.IEventRecorder GetEventRecorder(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; } + } + public class RecordedEvent + { + public RecordedEvent(System.DateTime utcNow, object monitoredObject, params object[] parameters) { } + public System.Collections.Generic.IEnumerable Parameters { get; } + public System.DateTime TimestampUtc { get; set; } + } +} +namespace FluentAssertions.Execution +{ + public class AssertionFailedException : System.Exception + { + public AssertionFailedException(string message) { } + protected AssertionFailedException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { } + } + public class AssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public AssertionScope() { } + public AssertionScope(FluentAssertions.Execution.IAssertionStrategy assertionStrategy) { } + public AssertionScope(string context) { } + public string Context { get; set; } + public bool Succeeded { 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, string value) { } + 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, params object[] args) { } + public FluentAssertions.Execution.AssertionScope ForCondition(bool condition) { } + 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 Continuation(FluentAssertions.Execution.AssertionScope sourceScope, bool sourceSucceeded) { } + public bool SourceSucceeded { get; } + public FluentAssertions.Execution.IAssertionScope Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.Continuation continuation) { } + } + public class ContinuationOfGiven + { + public ContinuationOfGiven(FluentAssertions.Execution.GivenSelector parent, bool succeeded) { } + public FluentAssertions.Execution.GivenSelector Then { get; } + public static bool op_Implicit(FluentAssertions.Execution.ContinuationOfGiven continuationOfGiven) { } + } + public class ContinuedAssertionScope : FluentAssertions.Execution.IAssertionScope, System.IDisposable + { + public ContinuedAssertionScope(FluentAssertions.Execution.AssertionScope predecessor, bool predecessorSucceeded) { } + public bool Succeeded { get; } + 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, 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 GivenSelector(System.Func selector, bool predecessorSucceeded, FluentAssertions.Execution.AssertionScope predecessor) { } + 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 + { + bool Succeeded { get; } + 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, 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(); + } +} +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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class AttributeBasedFormatter : FluentAssertions.Formatting.IValueFormatter + { + public AttributeBasedFormatter() { } + public System.Reflection.MethodInfo[] Formatters { get; } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DateTimeOffsetValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DateTimeOffsetValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class DecimalValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DecimalValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + protected virtual System.Collections.Generic.IEnumerable GetMembers(System.Type type) { } + protected virtual string TypeDisplayName(System.Type type) { } + } + public class DoubleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public DoubleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExceptionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExceptionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class ExpressionValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public ExpressionValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public delegate string FormatChild(string childPath, object value); + 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, bool useLineBreaks = false) { } + } + public class FormattingContext + { + public FormattingContext() { } + public int Depth { get; set; } + public bool UseLineBreaks { get; set; } + } + public class GuidValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public GuidValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public interface IValueFormatter + { + bool CanHandle(object value); + string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild); + } + public class Int16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class Int64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public Int64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class MultidimensionalArrayFormatter : FluentAssertions.Formatting.IValueFormatter + { + public MultidimensionalArrayFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class NullValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public NullValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class PropertyInfoFormatter : FluentAssertions.Formatting.IValueFormatter + { + public PropertyInfoFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SByteValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SByteValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class SingleValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public SingleValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class StringValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public StringValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TaskFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TaskFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class TimeSpanValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public TimeSpanValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt16ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt16ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt32ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt32ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class UInt64ValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public UInt64ValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XDocumentValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XDocumentValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } + public class XElementValueFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XElementValueFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, 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 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 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 T? Subject { get; } + 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 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 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 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 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 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.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 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 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 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 NotBeEmpty(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 Be(System.DateTime? 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 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 Be(System.DateTimeOffset? 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 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.ReferenceTypeAssertions + { + public ObjectAssertions(object value) { } + protected override string Identifier { get; } + public FluentAssertions.AndConstraint Be(object 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 HaveFlag(System.Enum expectedFlag, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBe(object 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 FluentAssertions.AndConstraint NotHaveFlag(System.Enum unexpectedFlag, 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 BeLessOrEqualTo(System.TimeSpan expected, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 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 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 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 NotBeNullOrEmpty(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotBeNullOrWhiteSpace(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 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 string[] becauseArgs) { } + public FluentAssertions.AndConstraint Reference(System.Reflection.Assembly assembly, string because = "", params string[] 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.DelegateAssertions, 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 FluentAssertions.AndConstraint CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + protected override void InvokeSubject() { } + 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 DelegateAssertions : FluentAssertions.Primitives.ReferenceTypeAssertions> + 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) { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, object[] becauseArgs) { } + public FluentAssertions.AndConstraint NotThrow(string because = "", params object[] becauseArgs) + where TException : System.Exception { } + protected FluentAssertions.AndConstraint NotThrow(System.Exception exception, string because, 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 { } + protected FluentAssertions.Specialized.ExceptionAssertions Throw(System.Exception exception, string because, 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) { } + public ExecutionTime(System.Func action) { } + protected ExecutionTime(System.Action action, string actionDescription) { } + protected ExecutionTime(System.Func action, string actionDescription) { } + } + 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 BeLessOrEqualTo(System.TimeSpan maxDuration, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndConstraint BeLessThan(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 FluentAssertions.AndWhichConstraint, TResult> CompleteWithin(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public System.Threading.Tasks.Task, TResult>> CompleteWithinAsync(System.TimeSpan timeSpan, string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrow(string because = "", params object[] becauseArgs) { } + public FluentAssertions.AndWhichConstraint, TResult> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, 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) { } + } + 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) { } + } +} +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 ThatAreDecoratedWith() + where TAttribute : System.Attribute { } + public FluentAssertions.Types.MethodInfoSelector ThatAreDecoratedWithOrInherit() + where TAttribute : System.Attribute { } + 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 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 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 BeSealed(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 NotBeSealed(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[] reasonArgs) { } + public FluentAssertions.AndConstraint NotBeEquivalentTo(System.Xml.XmlNode unexpected, string because = "", params object[] reasonArgs) { } + } + public class XmlNodeFormatter : FluentAssertions.Formatting.IValueFormatter + { + public XmlNodeFormatter() { } + public bool CanHandle(object value) { } + public string Format(object value, FluentAssertions.Formatting.FormattingContext context, FluentAssertions.Formatting.FormatChild formatChild) { } + } +} \ No newline at end of file