MyAvaloniaApp/
├── MyAvaloniaApp/              # Основний проєкт
│   ├── Views/
│   ├── ViewModels/
│   └── MyAvaloniaApp.csproj
├── MyAvaloniaApp.Tests/        # Unit-тести для ViewModels
│   └── MyAvaloniaApp.Tests.csproj
└── MyAvaloniaApp.HeadlessTests/  # Headless UI-тести
    └── MyAvaloniaApp.HeadlessTests.csproj

dotnet new xunit -n MyAvaloniaApp.HeadlessTests
cd MyAvaloniaApp.HeadlessTests
dotnet add package Avalonia.Headless.XUnit
dotnet add reference ../MyAvaloniaApp/MyAvaloniaApp.csproj

using Avalonia.Headless.XUnit;
using Xunit;

namespace MyAvaloniaApp.HeadlessTests;

public class MainWindowTests
{
    [AvaloniaTest]
    public void MainWindow_ShouldLoad()
    {
        // Arrange: створюємо вікно
        var window = new MainWindow();
        
        // Act: показуємо вікно (headless)
        window.Show();
        
        // Assert: перевіряємо, що вікно створилось
        Assert.NotNull(window);
        Assert.True(window.IsVisible);
    }
}

using Avalonia;
using Avalonia.Headless;
using Microsoft.Extensions.DependencyInjection;

namespace MyAvaloniaApp.HeadlessTests;

public class AppTestBase
{
    protected static void InitializeApp()
    {
        // Ініціалізуємо Avalonia Application один раз для всіх тестів
        if (Application.Current == null)
        {
            AppBuilder.Configure<App>()
                .UseHeadless(new AvaloniaHeadlessPlatformOptions())
                .SetupWithoutStarting();
        }
    }
    
    protected IServiceProvider Services => 
        ((App)Application.Current!).Services;
}

public class MainWindowTests : AppTestBase
{
    public MainWindowTests()
    {
        InitializeApp();
    }
    
    [AvaloniaTest]
    public void MainWindow_WithDI_ShouldResolveServices()
    {
        // Отримуємо сервіс з DI
        var userService = Services.GetRequiredService<IUserService>();
        
        // Створюємо вікно з ViewModel, який використовує сервіс
        var viewModel = new MainViewModel(userService);
        var window = new MainWindow { DataContext = viewModel };
        
        window.Show();
        
        Assert.NotNull(window.DataContext);
    }
}

<!-- MainWindow.axaml -->
<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="MyAvaloniaApp.Views.MainWindow">
    <StackPanel>
        <TextBox x:Name="UsernameTextBox" Watermark="Username" />
        <Button x:Name="LoginButton" Content="Login" />
        <TextBlock x:Name="StatusTextBlock" />
    </StackPanel>
</Window>

[AvaloniaTest]
public void LoginButton_Click_ShouldUpdateStatus()
{
    // Arrange
    var window = new MainWindow();
    window.Show();
    
    // Знаходимо контроли за Name
    var usernameTextBox = window.FindControl<TextBox>("UsernameTextBox");
    var loginButton = window.FindControl<Button>("LoginButton");
    var statusTextBlock = window.FindControl<TextBlock>("StatusTextBlock");
    
    Assert.NotNull(usernameTextBox);
    Assert.NotNull(loginButton);
    Assert.NotNull(statusTextBlock);
    
    // Act: вводимо username
    usernameTextBox.Text = "john_doe";
    
    // Симулюємо клік на кнопку
    loginButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
    
    // Assert: перевіряємо, що статус оновився
    Assert.Equal("Welcome, john_doe!", statusTextBlock.Text);
}

using Avalonia.VisualTree;

[AvaloniaTest]
public void Window_ShouldContainAllButtons()
{
    var window = new MainWindow();
    window.Show();
    
    // Знаходимо всі кнопки у вікні
    var buttons = window.GetVisualDescendants()
        .OfType<Button>()
        .ToList();
    
    Assert.Equal(3, buttons.Count);
    Assert.Contains(buttons, b => b.Content?.ToString() == "Login");
    Assert.Contains(buttons, b => b.Content?.ToString() == "Cancel");
    Assert.Contains(buttons, b => b.Content?.ToString() == "Help");
}

button.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));

// Якщо кнопка прив'язана до Command
if (button.Command?.CanExecute(button.CommandParameter) == true)
{
    button.Command.Execute(button.CommandParameter);
}

using Avalonia.Input;

// Симулюємо повну послідовність pointer events
button.RaiseEvent(new PointerPressedEventArgs(
    button,
    new Pointer(0, PointerType.Mouse, true),
    button,
    new Point(10, 10),
    0,
    new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.LeftButtonPressed),
    KeyModifiers.None));

button.RaiseEvent(new PointerReleasedEventArgs(
    button,
    new Pointer(0, PointerType.Mouse, true),
    button,
    new Point(10, 10),
    0,
    new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.LeftButtonReleased),
    KeyModifiers.None,
    MouseButton.Left));

[AvaloniaTest]
public void TextBox_KeyPress_ShouldUpdateText()
{
    var window = new MainWindow();
    window.Show();
    
    var textBox = window.FindControl<TextBox>("UsernameTextBox");
    textBox.Focus();
    
    // Симулюємо введення тексту по одній клавіші
    window.KeyPressQwerty(Key.H, RawInputModifiers.None);
    window.KeyPressQwerty(Key.E, RawInputModifiers.None);
    window.KeyPressQwerty(Key.L, RawInputModifiers.None);
    window.KeyPressQwerty(Key.L, RawInputModifiers.None);
    window.KeyPressQwerty(Key.O, RawInputModifiers.None);
    
    Assert.Equal("hello", textBox.Text);
}

[AvaloniaTest]
public void TextBox_CtrlA_ShouldSelectAll()
{
    var window = new MainWindow();
    window.Show();
    
    var textBox = window.FindControl<TextBox>("UsernameTextBox");
    textBox.Text = "Hello World";
    textBox.Focus();
    
    // Ctrl+A — виділити все
    window.KeyPressQwerty(Key.A, RawInputModifiers.Control);
    
    Assert.Equal("Hello World", textBox.SelectedText);
    Assert.Equal(0, textBox.SelectionStart);
    Assert.Equal(11, textBox.SelectionEnd);
}

[AvaloniaTest]
public void TextBox_ShiftKey_ShouldTypeUppercase()
{
    var window = new MainWindow();
    window.Show();
    
    var textBox = window.FindControl<TextBox>("UsernameTextBox");
    textBox.Focus();
    
    // Shift+H — велика літера
    window.KeyPressQwerty(Key.H, RawInputModifiers.Shift);
    
    Assert.Equal("H", textBox.Text);
}

[AvaloniaTest]
public void LoginForm_EnterKey_ShouldSubmit()
{
    var window = new MainWindow();
    window.Show();
    
    var usernameTextBox = window.FindControl<TextBox>("UsernameTextBox");
    var passwordTextBox = window.FindControl<TextBox>("PasswordTextBox");
    
    usernameTextBox.Focus();
    
    // Вводимо username
    foreach (var ch in "john_doe")
    {
        window.KeyPressQwerty(CharToKey(ch), RawInputModifiers.None);
    }
    
    // Tab — перехід до наступного поля
    window.KeyPressQwerty(Key.Tab, RawInputModifiers.None);
    
    Assert.True(passwordTextBox.IsFocused);
    
    // Вводимо password
    foreach (var ch in "secret123")
    {
        window.KeyPressQwerty(CharToKey(ch), RawInputModifiers.None);
    }
    
    // Enter — submit форми
    window.KeyPressQwerty(Key.Enter, RawInputModifiers.None);
    
    // Перевіряємо, що форма відправилась
    var viewModel = (LoginViewModel)window.DataContext;
    Assert.True(viewModel.IsLoggedIn);
}

private static Key CharToKey(char ch)
{
    // Спрощена конвертація char → Key
    return ch switch
    {
        'a' or 'A' => Key.A,
        'b' or 'B' => Key.B,
        // ... інші літери
        '_' => Key.OemMinus, // Underscore (Shift+Minus)
        _ => Key.None
    };
}

using Avalonia.Headless;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;

[AvaloniaTest]
public void MainWindow_Screenshot_ShouldMatchBaseline()
{
    // Arrange
    var window = new MainWindow();
    window.Show();
    
    // Act: робимо скріншот
    var screenshot = window.CaptureRenderedFrame();
    
    // Assert: перевіряємо розмір
    Assert.NotNull(screenshot);
    Assert.True(screenshot.Width > 0);
    Assert.True(screenshot.Height > 0);
    
    // Зберігаємо скріншот для візуального порівняння
    SaveScreenshot(screenshot, "MainWindow_Initial.png");
}

private void SaveScreenshot(IImage screenshot, string filename)
{
    var pixels = screenshot.GetPixels();
    using var image = Image.LoadPixelData<Bgra32>(
        pixels, 
        screenshot.Width, 
        screenshot.Height);
    
    image.SaveAsPng(filename);
}

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;

[AvaloniaTest]
public void Button_Hover_ShouldChangeAppearance()
{
    var window = new MainWindow();
    window.Show();
    
    var button = window.FindControl<Button>("LoginButton");
    
    // Скріншот у нормальному стані
    var normalScreenshot = window.CaptureRenderedFrame();
    
    // Симулюємо hover
    button.RaiseEvent(new PointerEventArgs(
        InputElement.PointerEnteredEvent,
        button,
        new Pointer(0, PointerType.Mouse, true),
        button,
        new Point(10, 10),
        0,
        new PointerPointProperties(),
        KeyModifiers.None));
    
    // Скріншот у hover стані
    var hoverScreenshot = window.CaptureRenderedFrame();
    
    // Порівнюємо скріншоти
    var difference = CompareImages(normalScreenshot, hoverScreenshot);
    
    // Очікуємо, що зображення відрізняються (hover змінює вигляд)
    Assert.True(difference > 0.01, "Button appearance should change on hover");
}

private double CompareImages(IImage img1, IImage img2)
{
    if (img1.Width != img2.Width || img1.Height != img2.Height)
        return 1.0; // Повністю різні
    
    var pixels1 = img1.GetPixels();
    var pixels2 = img2.GetPixels();
    
    int differentPixels = 0;
    for (int i = 0; i < pixels1.Length; i++)
    {
        if (pixels1[i] != pixels2[i])
            differentPixels++;
    }
    
    return (double)differentPixels / pixels1.Length;
}

dotnet add package Verify.Xunit
dotnet add package Verify.ImageSharp

using VerifyXunit;

[UsesVerify]
public class VisualRegressionTests
{
    [AvaloniaTest]
    public Task MainWindow_ShouldMatchSnapshot()
    {
        var window = new MainWindow();
        window.Show();
        
        var screenshot = window.CaptureRenderedFrame();
        var image = ConvertToImage(screenshot);
        
        // Verify автоматично збереже baseline при першому запуску
        // та порівнюватиме з ним при наступних запусках
        return Verifier.Verify(image);
    }
    
    private Image<Bgra32> ConvertToImage(IImage screenshot)
    {
        var pixels = screenshot.GetPixels();
        return Image.LoadPixelData<Bgra32>(
            pixels, 
            screenshot.Width, 
            screenshot.Height);
    }
}

[AvaloniaTest]
public void DataBinding_PropertyChange_ShouldUpdateUI()
{
    // Arrange
    var viewModel = new UserProfileViewModel
    {
        Username = "john_doe",
        Email = "john@example.com"
    };
    
    var window = new UserProfileWindow
    {
        DataContext = viewModel
    };
    window.Show();
    
    var usernameTextBlock = window.FindControl<TextBlock>("UsernameTextBlock");
    var emailTextBlock = window.FindControl<TextBlock>("EmailTextBlock");
    
    // Assert initial state
    Assert.Equal("john_doe", usernameTextBlock.Text);
    Assert.Equal("john@example.com", emailTextBlock.Text);
    
    // Act: змінюємо ViewModel
    viewModel.Username = "jane_smith";
    viewModel.Email = "jane@example.com";
    
    // Assert: UI оновився через Data Binding
    Assert.Equal("jane_smith", usernameTextBlock.Text);
    Assert.Equal("jane@example.com", emailTextBlock.Text);
}

// XAML:
// <TextBlock Text="{Binding IsActive, Converter={StaticResource BoolToStatusConverter}}" />

[AvaloniaTest]
public void BoolToStatusConverter_ShouldDisplayCorrectText()
{
    var viewModel = new UserViewModel { IsActive = true };
    var window = new UserWindow { DataContext = viewModel };
    window.Show();
    
    var statusTextBlock = window.FindControl<TextBlock>("StatusTextBlock");
    
    // Converter повинен перетворити true → "Active"
    Assert.Equal("Active", statusTextBlock.Text);
    
    // Змінюємо значення
    viewModel.IsActive = false;
    
    // Converter повинен перетворити false → "Inactive"
    Assert.Equal("Inactive", statusTextBlock.Text);
}

[AvaloniaTest]
public void Validation_InvalidEmail_ShouldShowError()
{
    var viewModel = new RegistrationViewModel();
    var window = new RegistrationWindow { DataContext = viewModel };
    window.Show();
    
    var emailTextBox = window.FindControl<TextBox>("EmailTextBox");
    var errorTextBlock = window.FindControl<TextBlock>("EmailErrorTextBlock");
    
    // Вводимо невалідний email
    emailTextBox.Text = "invalid-email";
    
    // Перевіряємо, що з'явилась помилка валідації
    Assert.True(viewModel.HasErrors);
    Assert.Contains("Invalid email format", viewModel.GetErrors("Email").Cast<string>());
    
    // Перевіряємо, що помилка відображається у UI
    Assert.True(errorTextBlock.IsVisible);
    Assert.Contains("Invalid email", errorTextBlock.Text);
    
    // Виправляємо email
    emailTextBox.Text = "valid@example.com";
    
    // Помилка зникла
    Assert.False(viewModel.HasErrors);
    Assert.False(errorTextBlock.IsVisible);
}

[AvaloniaTest]
public async Task LoadButton_Click_ShouldLoadDataAsync()
{
    // Arrange: mock сервіс
    var mockUserService = Substitute.For<IUserService>();
    mockUserService.GetUsersAsync()
        .Returns(Task.FromResult<IEnumerable<User>>(new[]
        {
            new User { Id = 1, Name = "John" },
            new User { Id = 2, Name = "Jane" }
        }));
    
    var viewModel = new UsersViewModel(mockUserService);
    var window = new UsersWindow { DataContext = viewModel };
    window.Show();
    
    var loadButton = window.FindControl<Button>("LoadButton");
    var listBox = window.FindControl<ListBox>("UsersListBox");
    var loadingIndicator = window.FindControl<ProgressBar>("LoadingIndicator");
    
    // Act: клікаємо кнопку завантаження
    loadButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
    
    // Під час завантаження показується індикатор
    Assert.True(loadingIndicator.IsVisible);
    Assert.False(loadButton.IsEnabled);
    
    // Чекаємо завершення асинхронної операції
    await Task.Delay(100); // Даємо час на виконання
    
    // Assert: дані завантажились
    Assert.False(loadingIndicator.IsVisible);
    Assert.True(loadButton.IsEnabled);
    Assert.Equal(2, listBox.ItemCount);
}

[AvaloniaTest]
public void NavigateToSettings_ShouldOpenSettingsPage()
{
    var window = new MainWindow();
    window.Show();
    
    var settingsButton = window.FindControl<Button>("SettingsButton");
    
    // Клікаємо кнопку Settings
    settingsButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
    
    // Перевіряємо, що відкрилась сторінка Settings
    var contentControl = window.FindControl<ContentControl>("MainContent");
    Assert.IsType<SettingsView>(contentControl.Content);
}

[AvaloniaTest]
public void ListBox_ItemsSource_ShouldDisplayAllItems()
{
    var viewModel = new ProductsViewModel
    {
        Products = new ObservableCollection<Product>
        {
            new Product { Id = 1, Name = "Laptop", Price = 999.99m },
            new Product { Id = 2, Name = "Mouse", Price = 29.99m },
            new Product { Id = 3, Name = "Keyboard", Price = 79.99m }
        }
    };
    
    var window = new ProductsWindow { DataContext = viewModel };
    window.Show();
    
    var listBox = window.FindControl<ListBox>("ProductsListBox");
    
    // Перевіряємо кількість елементів
    Assert.Equal(3, listBox.ItemCount);
    
    // Знаходимо ListBoxItem через Visual Tree
    var listBoxItems = listBox.GetVisualDescendants()
        .OfType<ListBoxItem>()
        .ToList();
    
    Assert.Equal(3, listBoxItems.Count);
    
    // Перевіряємо вміст першого елемента
    var firstItem = listBoxItems[0];
    var nameTextBlock = firstItem.GetVisualDescendants()
        .OfType<TextBlock>()
        .FirstOrDefault(tb => tb.Name == "ProductName");
    
    Assert.Equal("Laptop", nameTextBlock?.Text);
    
    // Додаємо новий продукт
    viewModel.Products.Add(new Product { Id = 4, Name = "Monitor", Price = 299.99m });
    
    // Перевіряємо, що ListBox оновився
    Assert.Equal(4, listBox.ItemCount);
}

MyApp.Tests/              # Unit-тести для ViewModels, Services
MyApp.HeadlessTests/      # Headless UI-тести

public class LoginWindowPageObject
{
    private readonly LoginWindow _window;
    
    public LoginWindowPageObject(LoginWindow window)
    {
        _window = window;
    }
    
    public TextBox UsernameTextBox => 
        _window.FindControl<TextBox>("UsernameTextBox");
    
    public TextBox PasswordTextBox => 
        _window.FindControl<TextBox>("PasswordTextBox");
    
    public Button LoginButton => 
        _window.FindControl<Button>("LoginButton");
    
    public TextBlock ErrorTextBlock => 
        _window.FindControl<TextBlock>("ErrorTextBlock");
    
    // Helper methods
    public void EnterCredentials(string username, string password)
    {
        UsernameTextBox.Text = username;
        PasswordTextBox.Text = password;
    }
    
    public void ClickLogin()
    {
        LoginButton.RaiseEvent(new RoutedEventArgs(Button.ClickEvent));
    }
    
    public bool IsErrorVisible => ErrorTextBlock.IsVisible;
    public string ErrorMessage => ErrorTextBlock.Text ?? string.Empty;
}

// Використання у тестах
[AvaloniaTest]
public void Login_InvalidCredentials_ShouldShowError()
{
    var window = new LoginWindow();
    window.Show();
    
    var page = new LoginWindowPageObject(window);
    
    page.EnterCredentials("invalid", "wrong");
    page.ClickLogin();
    
    Assert.True(page.IsErrorVisible);
    Assert.Contains("Invalid credentials", page.ErrorMessage);
}

public class AppTestFixture : IDisposable
{
    public IServiceProvider Services { get; }
    
    public AppTestFixture()
    {
        // Ініціалізація Application
        AppBuilder.Configure<App>()
            .UseHeadless(new AvaloniaHeadlessPlatformOptions())
            .SetupWithoutStarting();
        
        Services = ((App)Application.Current!).Services;
    }
    
    public T GetService<T>() where T : notnull => 
        Services.GetRequiredService<T>();
    
    public void Dispose()
    {
        // Cleanup
    }
}

public class LoginTests : IClassFixture<AppTestFixture>
{
    private readonly AppTestFixture _fixture;
    
    public LoginTests(AppTestFixture fixture)
    {
        _fixture = fixture;
    }
    
    [AvaloniaTest]
    public void Test_WithDI()
    {
        var userService = _fixture.GetService<IUserService>();
        // ...
    }
}

// Погано: створюємо вікно у кожному тесті
[AvaloniaTest]
public void Test1() { var w = new MainWindow(); w.Show(); /* ... */ }

[AvaloniaTest]
public void Test2() { var w = new MainWindow(); w.Show(); /* ... */ }

// Краще: використовуйте Test Fixture
public class MainWindowTests : IClassFixture<MainWindowFixture>
{
    private readonly MainWindow _window;
    
    public MainWindowTests(MainWindowFixture fixture)
    {
        _window = fixture.Window;
    }
    
    [AvaloniaTest]
    public void Test1() { /* використовуємо _window */ }
    
    [AvaloniaTest]
    public void Test2() { /* використовуємо _window */ }
}

// xUnit автоматично виконує тести з різних класів паралельно
[Collection("Sequential")] // Якщо потрібно sequential виконання
public class SequentialTests { }

// Погано: реальний HTTP запит у тесті
var service = new UserService(new HttpClient());

// Краще: mock
var mockService = Substitute.For<IUserService>();
mockService.GetUsersAsync().Returns(Task.FromResult(fakeUsers));

name: Headless Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'
    
    - name: Restore dependencies
      run: dotnet restore
    
    - name: Build
      run: dotnet build --no-restore
    
    - name: Run Headless Tests
      run: dotnet test MyApp.HeadlessTests --no-build --verbosity normal

[AvaloniaTest]
public void ClickButton_ShouldUpdateTextBlock()
{
    var window = new MainWindow();
    window.Show();
    
    var button = window.FindControl<Button>("ClickButton");
    var textBlock = window.FindControl<TextBlock>("StatusTextBlock");
    
    // TODO: клікнути кнопку та перевірити текст
}

[AvaloniaTest]
public void RegistrationForm_ValidInput_ShouldEnableButton()
{
    var window = new RegistrationWindow();
    window.Show();
    
    var usernameTextBox = window.FindControl<TextBox>("UsernameTextBox");
    usernameTextBox.Focus();
    
    // Вводимо username через KeyPress
    window.KeyTextInput("john_doe");
    
    // Tab до наступного поля
    window.KeyPressQwerty(Key.Tab, RawInputModifiers.None);
    
    // TODO: ввести email та password, перевірити стан кнопки
}

[AvaloniaTest]
public void Button_VisualStates_ShouldMatchBaseline()
{
    var window = new MainWindow();
    window.Show();
    
    var button = window.FindControl<Button>("ThemedButton");
    
    // Normal state
    var normalScreenshot = window.CaptureRenderedFrame();
    SaveAndCompare(normalScreenshot, "button_normal.png");
    
    // Hover state
    button.RaiseEvent(new PointerEventArgs(
        InputElement.PointerEnteredEvent,
        button,
        new Pointer(0, PointerType.Mouse, true),
        button,
        new Point(10, 10),
        0,
        new PointerPointProperties(),
        KeyModifiers.None));
    
    var hoverScreenshot = window.CaptureRenderedFrame();
    SaveAndCompare(hoverScreenshot, "button_hover.png");
    
    // TODO: додати pressed та disabled стани
}

private void SaveAndCompare(IImage screenshot, string filename)
{
    var baselinePath = Path.Combine("Baselines", filename);
    var currentPath = Path.Combine("Current", filename);
    
    SaveScreenshot(screenshot, currentPath);
    
    if (File.Exists(baselinePath))
    {
        var baseline = LoadScreenshot(baselinePath);
        var difference = CompareImages(screenshot, baseline);
        
        if (difference > 0.01) // 1% threshold
        {
            var diffPath = Path.Combine("Diffs", filename);
            SaveDiffImage(screenshot, baseline, diffPath);
            Assert.Fail($"Visual regression detected: {difference:P} difference");
        }
    }
    else
    {
        // Перший запуск — зберігаємо baseline
        SaveScreenshot(screenshot, baselinePath);
    }
}