public class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Divide(int a, int b) => a / b;
}

// "Тест" без фреймворку
class Program
{
    static void Main()
    {
        var calc = new Calculator();

        // Тест 1
        var result1 = calc.Add(2, 3);
        if (result1 != 5)
            Console.WriteLine($"FAIL: Add(2,3) expected 5, got {result1}");
        else
            Console.WriteLine("PASS: Add(2,3)");

        // Тест 2
        var result2 = calc.Add(-1, 1);
        if (result2 != 0)
            Console.WriteLine($"FAIL: Add(-1,1) expected 0, got {result2}");
        else
            Console.WriteLine("PASS: Add(-1,1)");

        // Тест 3: що станеться при Divide(5, 0)?
        try
        {
            var result3 = calc.Divide(5, 0);
            Console.WriteLine($"FAIL: Divide(5,0) should throw, got {result3}");
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("PASS: Divide(5,0) throws correctly");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"FAIL: Divide(5,0) threw wrong exception: {ex.GetType().Name}");
        }
    }
}

PASS: Add(2,3)
PASS: Add(-1,1)
PASS: Divide(5,0) throws correctly

Expected: 5
But was:  4
  at MyTests.CalculatorTests.Add_TwoPlusTwo_ReturnsFour()
     in C:\project\Tests\CalculatorTests.cs:line 15

// Спрощена демонстрація того, що робить Test Discovery
var assembly = Assembly.LoadFrom("MyProject.Tests.dll");

foreach (var type in assembly.GetTypes())
{
    foreach (var method in type.GetMethods())
    {
        // xUnit шукає [Fact] та [Theory]
        if (method.GetCustomAttribute<FactAttribute>() != null ||
            method.GetCustomAttribute<TheoryAttribute>() != null)
        {
            // Знайдено тест — додати до плану виконання
            testPlan.Add(new TestCase(type, method));
        }
    }
}

// Внутрішня логіка Assert.Equal
public static void Equal<T>(T expected, T actual)
{
    if (!EqualityComparer<T>.Default.Equals(expected, actual))
    {
        throw new EqualException(
            $"Expected: {FormatValue(expected)}\n" +
            $"Actual:   {FormatValue(actual)}"
        );
    }
}

// NUnit / MSTest: ОДИН об'єкт для ВСІХ тестів
[TestFixture] // NUnit
public class OrderServiceTests
{
    private OrderService _service; // Shared між тестами!

    [SetUp]
    public void SetUp()
    {
        _service = new OrderService(); // Викликається перед КОЖНИМ тестом
    }

    [Test]
    public void Test1() { /* використовує _service */ }

    [Test]
    public void Test2() { /* використовує той самий _service */ }
}

// xUnit: НОВИЙ об'єкт для КОЖНОГО тесту
public class OrderServiceTests
{
    private readonly OrderService _service;

    // Конструктор = SetUp, викликається перед КОЖНИМ тестом
    public OrderServiceTests()
    {
        _service = new OrderService();
    }

    [Fact]
    public void Test1() { /* отримує свій власний _service */ }

    [Fact]
    public void Test2() { /* отримує НОВИЙ _service, незалежний від Test1 */ }
}

// xUnit: контроль паралелізму
// Вимкнути паралелізм для всієї збірки:
[assembly: CollectionBehavior(DisableTestParallelization = true)]

// Об'єднати класи в колекцію (виконуються послідовно між собою):
[Collection("Integration Tests")]
public class DatabaseTests { ... }

[Collection("Integration Tests")]
public class CacheTests { ... }

// Стандартний xUnit — читабельність страждає
Assert.Equal(expected, actual);
Assert.NotNull(result);
Assert.True(result.IsSuccess);
Assert.Contains("error", result.Errors);

// FluentAssertions — читається як специфікація
result.Should().NotBeNull();
result.IsSuccess.Should().BeTrue();
result.Value.Should().Be(expected);
result.Errors.Should().Contain("error");
result.Items.Should().HaveCount(3).And.BeInAscendingOrder();

// Порівняння об'єктів: FluentAssertions показує ЯКЕ поле відрізняється
var actual = new User { Name = "John", Age = 25, Email = "wrong@email.com" };
var expected = new User { Name = "John", Age = 25, Email = "correct@email.com" };

// xUnit: "Expected: User { ... }, Actual: User { ... }" — не видно де різниця
Assert.Equal(expected, actual); // ❌ Незрозуміло

// FluentAssertions: "Expected Email to be 'correct@email.com' but found 'wrong@email.com'"
actual.Should().BeEquivalentTo(expected); // ✅ Точно вказує на Email

// Стандартний xUnit
var ex = Assert.Throws<InvalidOperationException>(() => service.DoSomething());
Assert.Equal("Expected message", ex.Message);

// FluentAssertions — одна зрозуміла конструкція
Action act = () => service.DoSomething();
act.Should()
   .Throw<InvalidOperationException>()
   .WithMessage("Expected message")
   .And.HaveInnerExceptionOfType<ArgumentException>();

// Для async
Func<Task> asyncAct = async () => await service.DoSomethingAsync();
await asyncAct.Should().ThrowAsync<InvalidOperationException>();

<!-- або у .csproj -->
<PackageReference Include="FluentAssertions" Version="6.*" />

// Без AutoFixture: потрібно заповнити всі поля вручну
var dto = new CreateOrderDto
{
    CustomerId = Guid.NewGuid(),
    Items = new List<OrderItemDto>
    {
        new OrderItemDto { ProductId = Guid.NewGuid(), Quantity = 1, Price = 10m }
    },
    ShippingAddress = new AddressDto
    {
        Street = "Test Street",
        City = "Kyiv",
        Country = "UA",
        PostalCode = "01001"
    },
    PaymentMethod = "card",
    // ... ще 10 полів
};
// Для тесту важливо лише CustomerId, решта — "dummy data"

// З AutoFixture: генерує всі поля автоматично
var fixture = new Fixture();
var dto = fixture.Create<CreateOrderDto>();

// Змінюємо лише те, що важливо для конкретного тесту
dto.CustomerId = specificCustomerId;

using AutoFixture.Xunit2;

public class OrderServiceTests
{
    // AutoFixture генерує dto автоматично!
    [Theory, AutoData]
    public void CreateOrder_WithValidData_ReturnsSuccess(CreateOrderDto dto)
    {
        var result = _service.CreateOrder(dto);
        result.IsSuccess.Should().BeTrue();
    }

    // Customizing + AutoData разом
    [Theory, AutoData]
    public void CreateOrder_WithNegativeAmount_ThrowsException(
        [Frozen] IOrderRepository mockRepo,
        CreateOrderDto dto,
        OrderService sut)  // AutoFixture будує весь граф залежностей!
    {
        dto.Amount = -100; // змінюємо лише важливе поле
        Action act = () => sut.CreateOrder(dto);
        act.Should().Throw<ValidationException>();
    }
}

using Bogus;

// Fluent builder для генерації User
var faker = new Faker<User>()
    .RuleFor(u => u.FirstName, f => f.Name.FirstName())
    .RuleFor(u => u.LastName, f => f.Name.LastName())
    .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FirstName, u.LastName))
    .RuleFor(u => u.Phone, f => f.Phone.PhoneNumber("+380 ## ### ####"))
    .RuleFor(u => u.BirthDate, f => f.Date.Past(50, DateTime.Now.AddYears(-18)))
    .RuleFor(u => u.City, f => f.Address.City());

// Генерація одного об'єкта
var user = faker.Generate();

// Генерація 100 об'єктів для bulk тестів
var users = faker.Generate(100);

Console.WriteLine(user.Email); // "john.doe@example.com" — реалістичний email
Console.WriteLine(user.Phone); // "+380 50 123 4567" — реалістичний номер

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
    <!-- Не виводити предостереження про тестовий проєкт -->
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>

  <ItemGroup>
    <!-- Основні пакети тестового фреймворку -->
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.*" />
    <PackageReference Include="xunit" Version="2.*" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.*" />

    <!-- Assertions -->
    <PackageReference Include="FluentAssertions" Version="6.*" />

    <!-- Mocking -->
    <PackageReference Include="Moq" Version="4.*" />

    <!-- Test data generation -->
    <PackageReference Include="AutoFixture" Version="4.*" />
    <PackageReference Include="AutoFixture.Xunit2" Version="4.*" />
    <PackageReference Include="Bogus" Version="34.*" />

    <!-- Coverage -->
    <PackageReference Include="coverlet.collector" Version="6.*" />
  </ItemGroup>

  <ItemGroup>
    <!-- Посилання на основний проєкт -->
    <ProjectReference Include="..\MyProject\MyProject.csproj" />
  </ItemGroup>

</Project>

// Назва файлу: {ClassName}Tests.cs
// OrderServiceTests.cs

// Назва класу: {ClassName}Tests
public class OrderServiceTests
{
    // Один тест-клас = один production клас
    // Виключення: складний клас може мати кілька тест-класів
    // OrderServiceCreateTests.cs, OrderServiceUpdateTests.cs
}

// Для nested classes (угрупування за методами):
public class OrderServiceTests
{
    public class CreateOrder
    {
        [Fact]
        public void WithValidData_ReturnsSuccess() { }

        [Fact]
        public void WithNullDto_ThrowsArgumentNull() { }
    }

    public class UpdateOrder
    {
        [Fact]
        public void WithNonExistentId_ReturnsNotFound() { }
    }
}

// GlobalUsings.cs у тестовому проєкті
global using Xunit;
global using FluentAssertions;
global using Moq;
global using AutoFixture;
global using AutoFixture.Xunit2;
global using System.Net;
global using Microsoft.Extensions.Logging.Abstractions;

<!-- В основному .csproj -->
<ItemGroup>
  <InternalsVisibleTo Include="MyProject.Tests" />
</ItemGroup>