using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using FluentAssertions.Execution;

namespace FluentAssertions.Primitives;

/// <summary>
/// Contains a number of methods to assert that a <see cref="Foo"/> is in the expected state.
/// </summary>
[DebuggerNonUserCode]
public class FooAssertions : FooAssertions<FooAssertions>
{
    public FooAssertions(Foo value, AssertionChain assertionChain)
        : base(value, assertionChain)
    {
    }
}

#pragma warning disable CS0659, S1206 // Ignore not overriding Object.GetHashCode()
#pragma warning disable CA1065 // Ignore throwing NotSupportedException from Equals
/// <summary>
/// Contains a number of methods to assert that a <see cref="Foo"/> is in the expected state.
/// </summary>
[DebuggerNonUserCode]
public class FooAssertions<TAssertions>
    where TAssertions : FooAssertions<TAssertions>
{
    private readonly AssertionChain assertionChain;

    public FooAssertions(Foo value, AssertionChain assertionChain)
    {
        this.assertionChain = assertionChain;
        Subject = value;
    }

    /// <summary>
    /// Gets the object whose value is being asserted.
    /// </summary>
    public Foo Subject { get; }

    /// <summary>
    /// Asserts that the foo satisfies some condition.
    /// </summary>
    /// <param name="because">
    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
    /// </param>
    /// <param name="becauseArgs">
    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
    /// </param>
    public AndConstraint<TAssertions> BeSomething(
        [StringSyntax("CompositeFormat")] string because = "",
        params object[] becauseArgs)
    {
        assertionChain
            .ForCondition(/* condition */)
            .BecauseOf(because, becauseArgs)
            .FailWith("Expected {context:foo} to be something{reason}.");

        return new AndConstraint<TAssertions>((TAssertions)this);
    }
}

using System;
using Xunit;
using Xunit.Sdk;

namespace FluentAssertions.Specs.Primitives;

public partial class FooAssertionSpecs
{
    public class BeSomething  // One nested class per assertion method
    {
        [Fact]
        public void Succeeds_for_foo_with_the_expected_value()
        {
            // Arrange
            var subject = new Foo(expectedValue);

            // Act / Assert
            subject.Should().BeSomething();
        }

        [Fact]
        public void The_foo_must_satisfy_some_condition()
        {
            // Arrange
            var subject = new Foo(unexpectedValue);

            // Act
            Action act = () => subject.Should().BeSomething();

            // Assert
            act.Should().Throw<XunitException>()
                .WithMessage("Expected foo to be something*");
        }

        [Fact]
        public void Fails_for_null_foo()
        {
            // Arrange
            Foo subject = null;

            // Act
            Action act = () => subject.Should().BeSomething();

            // Assert
            act.Should().Throw<XunitException>();
        }
    }
}