Разработка собственного фреймворка для тестирования в C#

public abstract class TestCase
{
    public abstract void Run();
    public virtual void Setup() {}
    public virtual void TearDown() {}
}

public class TestRunner
{
    private List<TestCase> _testCases = new List<TestCase>();
 
    public void RegisterTest(TestCase test)
    {
        _testCases.Add(test);
    }
 
    public TestResults RunAll()
    {
        var results = new TestResults();
        foreach (var test in _testCases)
        {
            // Запускаем тест и собираем результаты
        }
        return results;
    }
}

public interface ITestExecutionStrategy 
{
    TestResult Execute(TestCase testCase);
}
 
public class StandardExecution : ITestExecutionStrategy 
{
    public TestResult Execute(TestCase testCase) 
    {
        try 
        {
            testCase.Setup();
            testCase.Run();
            testCase.TearDown();
            return new TestResult(Status.Success);
        }
        catch (Exception ex) 
        {
            return new TestResult(Status.Failed, ex);
        }
    }
}
 
public class RetryingExecution : ITestExecutionStrategy 
{
    private int _maxRetries;
    
    public RetryingExecution(int maxRetries) 
    {
        _maxRetries = maxRetries;
    }
    
    public TestResult Execute(TestCase testCase) 
    {
        // Логика с повторными попытками  
    }
}

public class TestContext 
{
private Dictionary<string, object> _state = new Dictionary<string, object>();
private Stack<Dictionary<string, object>> _stateSnapshots = new Stack<Dictionary<string, object>>();
 
public void SetValue(string key, object value) 
{
    _state[key] = value;
}
 
public T GetValue<T>(string key) 
{
    return (T)_state[key];
}
 
public void SaveSnapshot() 
{
    _stateSnapshots.Push(new Dictionary<string, object>(_state));
}
 
public void RestoreSnapshot() 
{
    if (_stateSnapshots.Count > 0)
        _state = _stateSnapshots.Pop();
}
}

// Новый интерфейс
public interface IModernAssertion 
{
void AssertEquals<T>(T expected, T actual, IEqualityComparer<T> comparer);
}
 
// Адаптер для старого кода
public class LegacyAssertionAdapter : IModernAssertion 
{
private LegacyAssertion _legacyAssertion;
 
public LegacyAssertionAdapter(LegacyAssertion legacyAssertion) 
{
    _legacyAssertion = legacyAssertion;
}
 
public void AssertEquals<T>(T expected, T actual, IEqualityComparer<T> comparer) 
{
    if (!comparer.Equals(expected, actual))
        _legacyAssertion.Fail($"Expected {expected}, but was {actual}");
}
}

// Вместо серии отдельных утверждений
Assert.Contains(result, "expected text");
Assert.DoesNotContain(result, "forbidden text");
Assert.StartsWith(result, "Hello");
 
// Можно использовать цепочку утверждений
Check.That(result)
    .Contains("expected text")
    .DoesNotContain("forbidden text")
    .StartsWith("Hello");

TestConfiguration.Current
    .WithTimeout(TimeSpan.FromSeconds(30))
    .WithRetryCount(3)
    .WithParallelExecution(maxThreads: 4);
 
runner.RunTests();
 
// Изменяем конфигурацию на лету
TestConfiguration.Current
    .WithRetryCount(0)
    .WithParallelExecution(false);
 
runner.RunTests();

[Test]
public void TestComplexScenario([FromGenerator(typeof(UserDataGenerator))] User user, 
                                [FromRange(1, 100, Step = 10)] int quantity)
{
// Тест с разными входными данными
}

public abstract class TestCase
{
    public string Name { get; }
    protected bool IsSuccess { get; private set; }
    protected string FailureMessage { get; private set; }
 
    protected TestCase(string name)
    {
        Name = name;
        IsSuccess = true;
    }
 
    public abstract void Execute();
 
    protected void Fail(string message)
    {
        IsSuccess = false;
        FailureMessage = message;
    }
 
    public virtual void Setup() { }
    public virtual void TearDown() { }
 
    public TestResult GetResult()
    {
        return new TestResult(Name, IsSuccess, FailureMessage);
    }
}

public class TestResult
{
    public string TestName { get; }
    public bool IsSuccess { get; }
    public string FailureMessage { get; }
    public TimeSpan ExecutionTime { get; set; }
 
    public TestResult(string testName, bool isSuccess, string failureMessage = null)
    {
        TestName = testName;
        IsSuccess = isSuccess;
        FailureMessage = failureMessage;
    }
}

public class TestDiscoverer
{
    public List<Type> DiscoverTestCases(Assembly assembly)
    {
        return assembly.GetTypes()
            .Where(t => !t.IsAbstract && typeof(TestCase).IsAssignableFrom(t))
            .ToList();
    }
 
    public TestCase CreateTestInstance(Type testType, string testName = null)
    {
        // Используем имя класса как имя теста, если не указано явно
        if (string.IsNullOrEmpty(testName))
            testName = testType.Name;
 
        // Пробуем найти конструктор с параметром string
        var ctor = testType.GetConstructor(new[] { typeof(string) });
        if (ctor != null)
            return (TestCase)ctor.Invoke(new object[] { testName });
 
        // Если не нашли — пробуем конструктор по-умолчанию
        ctor = testType.GetConstructor(Type.EmptyTypes);
        if (ctor != null)
        {
            var instance = (TestCase)ctor.Invoke(null);
            // Здесь может понадобиться рефлексия для установки имени
            return instance;
        }
 
        throw new InvalidOperationException($"Не найден подхдящий конструктор для {testType.Name}");
    }
}

public class TestRunner
{
    private readonly List<TestCase> _tests = new List<TestCase>();
    private readonly List<TestResult> _results = new List<TestResult>();
 
    public void AddTest(TestCase test)
    {
        _tests.Add(test);
    }
 
    public void RunAll()
    {
        foreach (var test in _tests)
        {
            var sw = Stopwatch.StartNew();
            
            try
            {
                test.Setup();
                test.Execute();
            }
            catch (Exception ex)
            {
                // Если во время выполнения произошло исключение, 
                // считаем тест проваленным
                typeof(TestCase).GetMethod("Fail", 
                    BindingFlags.NonPublic | BindingFlags.Instance)
                    .Invoke(test, new object[] { ex.Message });
            }
            finally
            {
                try
                {
                    test.TearDown();
                }
                catch
                {
                    // Игнорируем ошибки в TearDown для упрощения
                }
            }
 
            sw.Stop();
            
            var result = test.GetResult();
            result.ExecutionTime = sw.Elapsed;
            _results.Add(result);
        }
    }
 
    public List<TestResult> GetResults()
    {
        return _results;
    }
}

public static class Assert
{
    public static void IsTrue(bool condition, string message = "Условие должно быть истинным")
    {
        if (!condition)
            throw new AssertionException(message);
    }
 
    public static void IsFalse(bool condition, string message = "Условие должно быть ложным")
    {
        if (condition)
            throw new AssertionException(message);
    }
 
    public static void AreEqual<T>(T expected, T actual, string message = null)
    {
        if (!EqualityComparer<T>.Default.Equals(expected, actual))
        {
            message = message ?? $"Ожидалось {expected}, получено {actual}";
            throw new AssertionException(message);
        }
    }
 
    public static void IsNull(object value, string message = "Значение должно быть null")
    {
        if (value != null)
            throw new AssertionException(message);
    }
 
    // Другие полезные ассерты...
}
 
public class AssertionException : Exception
{
    public AssertionException(string message) : base(message) { }
}

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class CategoryAttribute : Attribute
{
public string Name { get; }
 
public CategoryAttribute(string name)
{
    Name = name;
}
}
 
// Использование
[Category("DataAccess")]
[Category("SlowTests")]
public class DatabaseTests : TestCase
{
    // ...
}

public class TestDiscoverer
{
public List<TestInfo> DiscoverTests(Assembly assembly, string categoryFilter = null)
{
    var testInfos = new List<TestInfo>();
    var testTypes = assembly.GetTypes()
        .Where(t => !t.IsAbstract && typeof(TestCase).IsAssignableFrom(t));
        
    foreach (var type in testTypes)
    {
        var categories = type.GetCustomAttributes<CategoryAttribute>()
                             .Select(a => a.Name)
                             .ToList();
                             
        // Если указан фильтр и тест не попадает ни в одну подходящую категорию,
        // пропускаем его
        if (!string.IsNullOrEmpty(categoryFilter) && 
            !categories.Contains(categoryFilter))
            continue;
            
        testInfos.Add(new TestInfo 
        { 
            Type = type, 
            Categories = categories 
        });
    }
    
    return testInfos;
}
}
 
public class TestInfo
{
public Type Type { get; set; }
public List<string> Categories { get; set; } = new List<string>();
}

public class PerformanceMetrics
{
public TimeSpan ExecutionTime { get; }
public long MemoryUsedBytes { get; }
 
public PerformanceMetrics(TimeSpan executionTime, long memoryUsedBytes)
{
    ExecutionTime = executionTime;
    MemoryUsedBytes = memoryUsedBytes;
}
 
public override string ToString()
{
    return $"Время выполнения: {ExecutionTime.TotalMilliseconds} мс, " +
           $"Использовано памяти: {MemoryUsedBytes / 1024} КБ";
}
}
 
// Дополним наш класс TestResult
public class TestResult
{
public string TestName { get; }
public bool IsSuccess { get; }
public string FailureMessage { get; }
public PerformanceMetrics Metrics { get; set; }
 
public TestResult(string testName, bool isSuccess, string failureMessage = null)
{
    TestName = testName;
    IsSuccess = isSuccess;
    FailureMessage = failureMessage;
}
}

public void RunAll()
{
foreach (var test in _tests)
{
    var sw = Stopwatch.StartNew();
    var memoryBefore = GC.GetTotalMemory(true);
    
    try
    {
        test.Setup();
        test.Execute();
    }
    catch (Exception ex)
    {
        // Обработка исключений как раньше...
    }
    finally
    {
        try { test.TearDown(); } catch { /* ... */ }
    }
 
    sw.Stop();
    var memoryAfter = GC.GetTotalMemory(false);
    var memoryUsed = memoryAfter - memoryBefore;
    
    var result = test.GetResult();
    result.Metrics = new PerformanceMetrics(sw.Elapsed, memoryUsed);
    _results.Add(result);
}
}

public interface IDataGenerator<T>
{
IEnumerable<T> GenerateData();
}
 
public class IntRangeGenerator : IDataGenerator<int>
{
private readonly int _start;
private readonly int _end;
private readonly int _step;
 
public IntRangeGenerator(int start, int end, int step = 1)
{
    _start = start;
    _end = end;
    _step = step;
}
 
public IEnumerable<int> GenerateData()
{
    for (int i = _start; i <= _end; i += _step)
        yield return i;
}
}
 
// Теперь модифицируем базовый класс TestCase для поддержки параметризации
public abstract class ParameterizedTestCase<T> : TestCase
{
private readonly IDataGenerator<T> _generator;
 
protected ParameterizedTestCase(string name, IDataGenerator<T> generator) 
    : base(name)
{
    _generator = generator;
}
 
public override void Execute()
{
    foreach (var dataItem in _generator.GenerateData())
    {
        ExecuteWithData(dataItem);
    }
}
 
protected abstract void ExecuteWithData(T data);
}

public class EvenNumberTest : ParameterizedTestCase<int>
{
public EvenNumberTest() 
    : base("Проверка чётных чисел", new IntRangeGenerator(2, 20, 2))
{
}
 
protected override void ExecuteWithData(int data)
{
    Assert.IsTrue(data % 2 == 0, $"Число {data} должно быть чётным");
}
}

[AttributeUsage(AttributeTargets.Class)]
public class RetryAttribute : Attribute
{
    public int MaxRetries { get; }
 
    public RetryAttribute(int maxRetries)
    {
        MaxRetries = maxRetries;
    }
}
 
// Теперь модифицируем TestRunner для поддержки перезапусков
public void RunAll()
{
    foreach (var test in _tests)
    {
        var retryAttr = test.GetType().GetCustomAttribute<RetryAttribute>();
        int maxRetries = retryAttr?.MaxRetries ?? 0;
        int attempt = 0;
        bool success = false;
        TestResult finalResult = null;
 
        while (!success && attempt <= maxRetries)
        {
            attempt++;
            var sw = Stopwatch.StartNew();
            var memoryBefore = GC.GetTotalMemory(true);
 
            try
            {
                test.Setup();
                test.Execute();
                // Если дошли до этой точки без исключений,
                // значит тест прошел успешно
                success = true;
            }
            catch (Exception ex)
            {
                if (attempt > maxRetries)
                {
                    // Используем рефлексию, чтобы вызвать protected метод Fail
                    typeof(TestCase).GetMethod("Fail", 
                        BindingFlags.NonPublic | BindingFlags.Instance)
                        .Invoke(test, new object[] 
                        { $"Тест провален после {attempt} попыток: {ex.Message}" });
                }
            }
            finally
            {
                try { test.TearDown(); } catch { /* ... */ }
            }
 
            sw.Stop();
            var memoryAfter = GC.GetTotalMemory(false);
 
            finalResult = test.GetResult();
            finalResult.Metrics = new PerformanceMetrics(sw.Elapsed, memoryAfter - memoryBefore);
            finalResult.Attempts = attempt;
            
            if (success) break;
        }
 
        if (finalResult != null)
            _results.Add(finalResult);
    }
}

public class TestResult
{
    // Существующие свойства...
    public int Attempts { get; set; } = 1;
}

public enum TestPriority
{
    Critical = 0,
    High = 1,
    Medium = 2,
    Low = 3
}
 
[AttributeUsage(AttributeTargets.Class)]
public class PriorityAttribute : Attribute
{
    public TestPriority Priority { get; }
 
    public PriorityAttribute(TestPriority priority)
    {
        Priority = priority;
    }
}

public void RunAllPrioritized()
{
    // Сортируем тесты по приоритету
    var prioritizedTests = _tests
        .OrderBy(t => {
            var attr = t.GetType().GetCustomAttribute<PriorityAttribute>();
            return attr?.Priority ?? TestPriority.Medium;
        })
        .ToList();
        
    // А дальше используем обычную логику запуска
    foreach (var test in prioritizedTests)
    {
        // логика запуска тестов...
    }
}

public class TestContainer
{
    private Dictionary<Type, Func<object>> _registrations = 
        new Dictionary<Type, Func<object>>();
        
    public void Register<T>(Func<T> factory)
    {
        _registrations[typeof(T)] = () => factory();
    }
    
    public T Resolve<T>()
    {
        if (_registrations.TryGetValue(typeof(T), out var factory))
            return (T)factory();
            
        throw new InvalidOperationException($"Тип {typeof(T).Name} не зарегистрирован в контейнере");
    }
}

public class CommandLineRunner
{
private readonly TestRunner _runner = new TestRunner();
private readonly TestDiscoverer _discoverer = new TestDiscoverer();
 
public int Run(string[] args)
{
    string assemblyPath = null;
    string outputPath = "test-results.xml";
    string category = null;
    
    // Примитивный парсер аргументов
    for (int i = 0; i < args.Length; i++)
    {
        if (args[i] == "--assembly" && i + 1 < args.Length)
            assemblyPath = args[i + 1];
        else if (args[i] == "--output" && i + 1 < args.Length)
            outputPath = args[i + 1];
        else if (args[i] == "--category" && i + 1 < args.Length)
            category = args[i + 1];
    }
    
    if (string.IsNullOrEmpty(assemblyPath))
    {
        Console.WriteLine("Ошибка: путь к сборке не указан");
        return -1;
    }
    
    // Загрузка сборки и обнаружение тестов
    var assembly = Assembly.LoadFrom(assemblyPath);
    var testInfos = _discoverer.DiscoverTests(assembly, category);
    
    foreach (var info in testInfos)
    {
        var test = _discoverer.CreateTestInstance(info.Type);
        _runner.AddTest(test);
    }
    
    // Запуск тестов
    _runner.RunAll();
    
    // Генерация отчета
    var reporter = new XmlReporter(outputPath);
    reporter.GenerateReport(_runner.GetResults());
    
    int failedCount = _runner.GetResults().Count(r => !r.IsSuccess);
    Console.WriteLine($"Всего тестов: {_runner.GetResults().Count}, " +
                     $"Провалено: {failedCount}");
    
    return failedCount > 0 ? 1 : 0;
}
}

public class XmlReporter
{
private readonly string _outputPath;
 
public XmlReporter(string outputPath)
{
    _outputPath = outputPath;
}
 
public void GenerateReport(List<TestResult> results)
{
    using (var writer = XmlWriter.Create(_outputPath, new XmlWriterSettings 
    { 
        Indent = true 
    }))
    {
        writer.WriteStartDocument();
        writer.WriteStartElement("testsuites");
        
        writer.WriteStartElement("testsuite");
        writer.WriteAttributeString("name", "CustomFramework");
        writer.WriteAttributeString("tests", results.Count.ToString());
        writer.WriteAttributeString("failures", 
            results.Count(r => !r.IsSuccess).ToString());
        writer.WriteAttributeString("timestamp", 
            DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss"));
        
        foreach (var result in results)
        {
            writer.WriteStartElement("testcase");
            writer.WriteAttributeString("name", result.TestName);
            writer.WriteAttributeString("time", 
                result.Metrics.ExecutionTime.TotalSeconds.ToString());
            
            if (!result.IsSuccess)
            {
                writer.WriteStartElement("failure");
                writer.WriteAttributeString("message", result.FailureMessage);
                writer.WriteEndElement(); // failure
            }
            
            writer.WriteEndElement(); // testcase
        }
        
        writer.WriteEndElement(); // testsuite
        writer.WriteEndElement(); // testsuites
        writer.WriteEndDocument();
    }
}
}

public class ParallelTestRunner : TestRunner
{
private int _maxConcurrency;
 
public ParallelTestRunner(int maxConcurrency = 0)
{
    // Если maxConcurrency не указан, используем количество процессоров
    _maxConcurrency = maxConcurrency > 0 
        ? maxConcurrency 
        : Environment.ProcessorCount;
}
 
public override void RunAll()
{
    var testList = GetTests();
    var results = new ConcurrentBag<TestResult>();
    
    // Группируем тесты, которые не могут выполняться параллельно
    var nonParallelTests = testList
        .Where(t => t.GetType().GetCustomAttribute<NonParallelAttribute>() != null)
        .ToList();
    
    var parallelTests = testList
        .Except(nonParallelTests)
        .ToList();
    
    // Сначала выполняем параллельные тесты
    Parallel.ForEach(
        parallelTests, 
        new ParallelOptions { MaxDegreeOfParallelism = _maxConcurrency },
        test => {
            var result = RunSingleTest(test);
            results.Add(result);
        });
    
    // Затем последовательно выполняем тесты, которые нельзя запускать параллельно
    foreach (var test in nonParallelTests)
    {
        var result = RunSingleTest(test);
        results.Add(result);
    }
    
    SetResults(results.ToList());
}
 
// Вспомогательный метод для запуска отдельного теста
private TestResult RunSingleTest(TestCase test)
{
    // Логика выполнения теста, как и раньше...
    // ...
}
}

[AttributeUsage(AttributeTargets.Class)]
public class NonParallelAttribute : Attribute
{
}

public static class ExceptionAssert
{
public static void Throws<TException>(Action action, string message = null) 
    where TException : Exception
{
    try
    {
        action();
        throw new AssertionException(
            message ?? $"Ожидалось исключение типа {typeof(TException).Name}, " +
                     "но оно не было выброшено");
    }
    catch (TException)
    {
        // Все хорошо, мы получили ожидаемое исключение
    }
    catch (Exception ex)
    {
        throw new AssertionException(
            message ?? $"Ожидалось исключение типа {typeof(TException).Name}, " +
                     $"но было получено {ex.GetType().Name}");
    }
}
 
public static async Task ThrowsAsync<TException>(Func<Task> asyncAction, string message = null) 
    where TException : Exception
{
    try
    {
        await asyncAction();
        throw new AssertionException(
            message ?? $"Ожидалось исключение типа {typeof(TException).Name}, " +
                     "но оно не было выброшено");
    }
    catch (TException)
    {
        // Все хорошо, мы получили ожидаемое исключение
    }
    catch (Exception ex)
    {
        throw new AssertionException(
            message ?? $"Ожидалось исключение типа {typeof(TException).Name}, " +
                     $"но было получено {ex.GetType().Name}");
    }
}
}

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class RunOnlyIfAttribute : Attribute
{
public Predicate<TestEnvironment> Condition { get; }
public string SkipReason { get; }
 
public RunOnlyIfAttribute(Predicate<TestEnvironment> condition, string skipReason)
{
    Condition = condition;
    SkipReason = skipReason;
}
}
 
public class TestEnvironment
{
public string OsName => RuntimeInformation.OSDescription;
public bool IsWindows => RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
public bool IsLinux => RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
public bool IsMacOS => RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
public bool IsDebug => 
    #if DEBUG
        true;
    #else
        false;
    #endif
}

public void RunAll()
{
    var environment = new TestEnvironment();
    
    foreach (var test in _tests)
    {
        var skipTest = false;
        string skipReason = null;
        
        // Проверяем условные атрибуты
        var conditionalAttrs = test.GetType()
            .GetCustomAttributes<RunOnlyIfAttribute>();
            
        foreach (var attr in conditionalAttrs)
        {
            if (!attr.Condition(environment))
            {
                skipTest = true;
                skipReason = attr.SkipReason;
                break;
            }
        }
        
        if (skipTest)
        {
            // Создаём пропущенный результат
            var result = new TestResult(test.Name, true)
            {
                Status = TestStatus.Skipped,
                SkipReason = skipReason
            };
            _results.Add(result);
            continue;
        }
        
        // Логика запуска тестов...
    }
}

public enum TestStatus
{
    Success,
    Failed,
    Skipped
}
 
public class TestResult
{
    // Существующие свойства...
    public TestStatus Status { get; set; } = TestStatus.Success;
    public string SkipReason { get; set; }
    
    // Оставляем свойство IsSuccess для обратной совместимости
    public bool IsSuccess => Status == TestStatus.Success;
}

public interface IMockFactory
{
    T CreateMock<T>() where T : class;
}
 
public class SimpleMockFactory : IMockFactory
{
    private Dictionary<Type, object> _mocks = new Dictionary<Type, object>();
    
    public T CreateMock<T>() where T : class
    {
        if (_mocks.TryGetValue(typeof(T), out var existingMock))
            return (T)existingMock;
            
        var mockType = typeof(T).IsInterface 
            ? DynamicMockGenerator.CreateMockType(typeof(T))
            : throw new NotSupportedException($"Тип {typeof(T).Name} не является интерфейсом");
            
        var mock = Activator.CreateInstance(mockType);
        _mocks[typeof(T)] = mock;
        return (T)mock;
    }
}

public class HtmlReporter
{
    private readonly string _outputPath;
    
    public HtmlReporter(string outputPath)
    {
        _outputPath = outputPath;
    }
    
    public void GenerateReport(List<TestResult> results)
    {
        var sb = new StringBuilder();
        sb.AppendLine("<!DOCTYPE html>");
        sb.AppendLine("<html>");
        sb.AppendLine("<head>");
        sb.AppendLine("  <title>Результаты тестирования</title>");
        sb.AppendLine("  <style>");
        sb.AppendLine("    .success { color: green; }");
        sb.AppendLine("    .failure { color: red; }");
        sb.AppendLine("    .skipped { color: gray; }");
        sb.AppendLine("    table { border-collapse: collapse; width: 100%; }");
        sb.AppendLine("    th, td { border: 1px solid #ddd; padding: 8px; }");
        sb.AppendLine("    tr:nth-child(even) { background-color: #f2f2f2; }");
        sb.AppendLine("  </style>");
        sb.AppendLine("</head>");
        sb.AppendLine("<body>");
        
        sb.AppendLine("<h1>Результаты тестирования</h1>");
        
        // Статистика
        int total = results.Count;
        int passed = results.Count(r => r.Status == TestStatus.Success);
        int failed = results.Count(r => r.Status == TestStatus.Failed);
        int skipped = results.Count(r => r.Status == TestStatus.Skipped);
        
        sb.AppendLine("<div class='summary'>");
        sb.AppendLine($"  <p>Всего тестов: {total}</p>");
        sb.AppendLine($"  <p class='success'>Успешных: {passed}</p>");
        sb.AppendLine($"  <p class='failure'>Проваленных: {failed}</p>");
        sb.AppendLine($"  <p class='skipped'>Пропущенных: {skipped}</p>");
        sb.AppendLine("</div>");
        
        // Таблица с результатами
        sb.AppendLine("<table>");
        sb.AppendLine("  <tr>");
        sb.AppendLine("    <th>Тест</th>");
        sb.AppendLine("    <th>Статус</th>");
        sb.AppendLine("    <th>Время (мс)</th>");
        sb.AppendLine("    <th>Сообщение</th>");
        sb.AppendLine("  </tr>");
        
        foreach (var result in results)
        {
            string statusClass = result.Status == TestStatus.Success ? "success" :
                                result.Status == TestStatus.Failed ? "failure" : "skipped";
            
            sb.AppendLine("  <tr>");
            sb.AppendLine($"    <td>{result.TestName}</td>");
            sb.AppendLine($"    <td class='{statusClass}'>{result.Status}</td>");
            sb.AppendLine($"    <td>{result.Metrics?.ExecutionTime.TotalMilliseconds ?? 0}</td>");
            sb.AppendLine($"    <td>{(result.Status == TestStatus.Failed ? result.FailureMessage : result.SkipReason ?? "")}</td>");
            sb.AppendLine("  </tr>");
        }
        
        sb.AppendLine("</table>");
        sb.AppendLine("</body>");
        sb.AppendLine("</html>");
        
        File.WriteAllText(_outputPath, sb.ToString());
    }
}

public class MicroserviceMock<T> : IDisposable
{
    private HttpListener _listener;
    private Dictionary<string, Func<HttpListenerRequest, T>> _responseHandlers;
    private Thread _listenerThread;
 
    public MicroserviceMock(string baseUrl)
    {
        _listener = new HttpListener();
        _listener.Prefixes.Add(baseUrl);
        _responseHandlers = new Dictionary<string, Func<HttpListenerRequest, T>>();
    }
 
    public void OnRequest(string path, Func<HttpListenerRequest, T> handler)
    {
        _responseHandlers[path] = handler;
    }
 
    public void Start()
    {
        _listener.Start();
        _listenerThread = new Thread(HandleRequests);
        _listenerThread.Start();
    }
 
    private void HandleRequests()
    {
        while (_listener.IsListening)
        {
            try
            {
                var context = _listener.GetContext();
                var request = context.Request;
                var response = context.Response;
                
                var path = request.Url.AbsolutePath;
                if (_responseHandlers.TryGetValue(path, out var handler))
                {
                    var result = handler(request);
                    var json = JsonSerializer.Serialize(result);
                    var buffer = Encoding.UTF8.GetBytes(json);
                    
                    response.ContentType = "application/json";
                    response.ContentLength64 = buffer.Length;
                    response.OutputStream.Write(buffer, 0, buffer.Length);
                }
                else
                {
                    response.StatusCode = 404;
                }
                
                response.Close();
            }
            catch (Exception)
            {
                // В боевом коде здесь будет логирование
            }
        }
    }
 
    public void Dispose()
    {
        _listener?.Stop();
        _listenerThread?.Join(1000);
    }
}

public class UserServiceTest : TestCase
{
    private MicroserviceMock<UserDto> _authServiceMock;
    
    public UserServiceTest() : base("Тест сервиса пользователей") { }
    
    public override void Setup()
    {
        _authServiceMock = new MicroserviceMock<UserDto>("http://localhost:9876/");
        _authServiceMock.OnRequest("/auth/validate", req => new UserDto 
        { 
            Id = 42, 
            Name = "Тестовый Пользователь", 
            Roles = new[] { "admin" } 
        });
        _authServiceMock.Start();
    }
    
    public override void Execute()
    {
        var userService = new UserService("http://localhost:9876/");
        var user = userService.GetCurrentUser("valid_token");
        
        Assert.AreEqual(42, user.Id);
        Assert.AreEqual("Тестовый Пользователь", user.Name);
        Assert.AreEqual(1, user.Roles.Length);
        Assert.AreEqual("admin", user.Roles[0]);
    }
    
    public override void TearDown()
    {
        _authServiceMock.Dispose();
    }
}

public static class FinancialAssert
{
    public static void AccountBalanceIsCorrect(
        Account expected, 
        Account actual, 
        decimal tolerance = 0.01m)
    {
        Assert.AreEqual(expected.Id, actual.Id, "Идентификаторы аккаунтов не совпадают");
        Assert.AreEqual(expected.Currency, actual.Currency, "Валюты не совпадают");
        
        decimal diff = Math.Abs(expected.Balance - actual.Balance);
        if (diff > tolerance)
        {
            throw new AssertionException(
                $"Баланс отличается больше, чем на допустимую погрешность: " +
                $"ожидалось {expected.Balance}, получено {actual.Balance}, " +
                $"разница {diff}, допустимо {tolerance}");
        }
        
        // Дополнительные проверки для финансовых транзакций...
    }
}

public static class DocumentAssert
{
  public static void ValidContract(Contract contract)
  {
      Assert.IsNotNull(contract, "Контракт не может быть null");
      Assert.IsNotNull(contract.Parties, "Список участников контракта не может быть пустым");
      Assert.IsTrue(contract.Parties.Count >= 2, "В контракте должно быть минимум две стороны");
      Assert.IsTrue(contract.StartDate < contract.EndDate, "Дата начала должна быть раньше даты окончания");
      
      foreach (var party in contract.Parties)
      {
          Assert.IsNotNull(party.Signature, $"Отсутствует подпись у {party.Name}");
          Assert.IsTrue(party.Signature.Date <= DateTime.Now, 
              $"Дата подписи {party.Signature.Date} не может быть в будущем");
      }
  }
}

public class LoadTestCase : TestCase
{
  protected readonly int Iterations;
  protected readonly int Concurrency;
  protected readonly TimeSpan Duration;
  
  private List<Metrics> _iterationMetrics = new List<Metrics>();
  
  public LoadTestCase(string name, int iterations, int concurrency, TimeSpan duration) 
      : base(name)
  {
      Iterations = iterations;
      Concurrency = concurrency;
      Duration = duration;
  }
  
  public override void Execute()
  {
      var sw = Stopwatch.StartNew();
      var tasks = new List<Task>();
      var barrier = new Barrier(Concurrency);
      
      for (int i = 0; i < Concurrency; i++)
      {
          tasks.Add(Task.Run(() => {
              // Синхронизация старта всех потоков
              barrier.SignalAndWait();
              
              int localIterations = Iterations / Concurrency;
              for (int j = 0; j < localIterations; j++)
              {
                  if (sw.Elapsed > Duration)
                      break;
                      
                  var iterSw = Stopwatch.StartNew();
                  ExecuteIteration();
                  iterSw.Stop();
                  
                  lock (_iterationMetrics)
                  {
                      _iterationMetrics.Add(new Metrics { 
                          Duration = iterSw.Elapsed,
                          ThreadId = Thread.CurrentThread.ManagedThreadId 
                      });
                  }
              }
          }));
      }
      
      Task.WaitAll(tasks.ToArray());
      sw.Stop();
      
      AnalyzeResults();
  }
  
  protected virtual void ExecuteIteration()
  {
      // Переопределяеться в конкретных тестах
  }
  
  private void AnalyzeResults()
  {
      var totalDuration = _iterationMetrics.Sum(m => m.Duration.TotalMilliseconds);
      var avgDuration = totalDuration / _iterationMetrics.Count;
      var maxDuration = _iterationMetrics.Max(m => m.Duration.TotalMilliseconds);
      var minDuration = _iterationMetrics.Min(m => m.Duration.TotalMilliseconds);
      
      Console.WriteLine($"Выполнено итераций: {_iterationMetrics.Count}");
      Console.WriteLine($"Среднее время: {avgDuration:F2} мс");
      Console.WriteLine($"Максимальное время: {maxDuration:F2} мс");
      Console.WriteLine($"Минимальное время: {minDuration:F2} мс");
      Console.WriteLine($"Операций в секунду: {_iterationMetrics.Count * 1000 / totalDuration:F2}");
  }
  
  private class Metrics
  {
      public TimeSpan Duration { get; set; }
      public int ThreadId { get; set; }
  }
}

public class ApiEndpointLoadTest : LoadTestCase
{
  private HttpClient _client = new HttpClient();
  
  public ApiEndpointLoadTest() 
      : base("Тест производительности API", 1000, 10, TimeSpan.FromMinutes(1))
  {
      _client.BaseAddress = new Uri("https://api.example.com");
  }
  
  protected override void ExecuteIteration()
  {
      var response = _client.GetAsync("/users").Result;
      response.EnsureSuccessStatusCode();
  }
}

public class CoverageRunner : TestRunner
{
  private readonly string _coverageToolPath;
  private readonly string _targetAssembly;
  
  public CoverageRunner(string coverageToolPath, string targetAssembly)
  {
      _coverageToolPath = coverageToolPath;
      _targetAssembly = targetAssembly;
  }
  
  public override void RunAll()
  {
      // Запускаем инструмент покрытия как внешний процесс
      var startInfo = new ProcessStartInfo
      {
          FileName = _coverageToolPath,
          Arguments = $"--target=\"{_targetAssembly}\" --output=\"coverage.xml\"",
          RedirectStandardOutput = true,
          UseShellExecute = false,
          CreateNoWindow = true
      };
      
      using (var process = Process.Start(startInfo))
      {
          process.WaitForExit();
          if (process.ExitCode != 0)
          {
              Console.WriteLine("Ошибка при запуске инструмента покрытия");
              return;
          }
      }
      
      // Теперь анализируем отчеты
      if (File.Exists("coverage.xml"))
      {
          // Парсинг XML-отчета о покрытии и вывод результатов
          AnalyzeCoverage("coverage.xml");
      }
  }
  
  private void AnalyzeCoverage(string reportPath)
  {
      // Здесь будет код для анализа отчета и вывода результатов
  }
}

private void AnalyzeCoverage(string reportPath)
{
    var doc = XDocument.Load(reportPath);
    var coverageByNamespace = doc.Descendants("class")
        .GroupBy(x => x.Attribute("namespace").Value)
        .Select(g => new {
            Namespace = g.Key,
            TotalLines = g.Sum(c => int.Parse(c.Attribute("lines").Value)),
            CoveredLines = g.Sum(c => int.Parse(c.Attribute("coveredlines").Value))
        })
        .OrderBy(x => x.Namespace)
        .ToList();
    
    Console.WriteLine("Отчет о покрытии кода:");
    Console.WriteLine("--------------------------------------------------");
    Console.WriteLine("Пространство имен      | Покрытие | Строки (покрыто/всего)");
    Console.WriteLine("--------------------------------------------------");
    
    foreach (var ns in coverageByNamespace)
    {
        var coverage = ns.TotalLines > 0 
            ? (float)ns.CoveredLines / ns.TotalLines * 100 
            : 0;
        Console.WriteLine($"{ns.Namespace.PadRight(22)} | {coverage,6:F1}% | {ns.CoveredLines,6}/{ns.TotalLines}");
    }
    
    // Общая статистика
    var totalLines = coverageByNamespace.Sum(x => x.TotalLines);
    var totalCovered = coverageByNamespace.Sum(x => x.CoveredLines);
    var totalCoverage = totalLines > 0 ? (float)totalCovered / totalLines * 100 : 0;
    
    Console.WriteLine("--------------------------------------------------");
    Console.WriteLine($"Общее покрытие: {totalCoverage:F1}% ({totalCovered}/{totalLines})");
}

public class EnhancedXmlReporter : XmlReporter
{
    private XDocument _coverageReport;
    
    public EnhancedXmlReporter(string outputPath, string coveragePath = null)
        : base(outputPath)
    {
        if (!string.IsNullOrEmpty(coveragePath) && File.Exists(coveragePath))
            _coverageReport = XDocument.Load(coveragePath);
    }
    
    public override void GenerateReport(List<TestResult> results)
    {
        using (var writer = XmlWriter.Create(OutputPath, new XmlWriterSettings { Indent = true }))
        {
            writer.WriteStartDocument();
            writer.WriteStartElement("testsuites");
            
            writer.WriteStartElement("testsuite");
            writer.WriteAttributeString("name", "CustomFramework");
            writer.WriteAttributeString("tests", results.Count.ToString());
            writer.WriteAttributeString("failures", 
                results.Count(r => !r.IsSuccess).ToString());
            writer.WriteAttributeString("timestamp", 
                DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss"));
            
            // Добавляем информацию о покрытии, если она доступна
            if (_coverageReport != null)
            {
                var totalLines = _coverageReport.Descendants("class")
                    .Sum(c => int.Parse(c.Attribute("lines")?.Value ?? "0"));
                var coveredLines = _coverageReport.Descendants("class")
                    .Sum(c => int.Parse(c.Attribute("coveredlines")?.Value ?? "0"));
                
                writer.WriteAttributeString("coverage", 
                    totalLines > 0 ? ((float)coveredLines / totalLines * 100).ToString("F1") + "%" : "N/A");
            }
            
            foreach (var result in results)
            {
                writer.WriteStartElement("testcase");
                writer.WriteAttributeString("name", result.TestName);
                writer.WriteAttributeString("time", 
                    result.Metrics.ExecutionTime.TotalSeconds.ToString());
                
                if (!result.IsSuccess)
                {
                    writer.WriteStartElement("failure");
                    writer.WriteAttributeString("message", result.FailureMessage);
                    writer.WriteEndElement(); // failure
                }
                
                // Если есть информация о покрытии для этого теста, добавляем её
                if (_coverageReport != null)
                {
                    var testClass = result.TestName.Split('.')[0];
                    var coverageInfo = _coverageReport.Descendants("class")
                        .FirstOrDefault(c => c.Attribute("name")?.Value == testClass);
                    
                    if (coverageInfo != null)
                    {
                        writer.WriteStartElement("coverage");
                        writer.WriteAttributeString("lines", 
                            coverageInfo.Attribute("lines")?.Value ?? "0");
                        writer.WriteAttributeString("coveredlines", 
                            coverageInfo.Attribute("coveredlines")?.Value ?? "0");
                        writer.WriteEndElement(); // coverage
                    }
                }
                
                writer.WriteEndElement(); // testcase
            }
            
            writer.WriteEndElement(); // testsuite
            writer.WriteEndElement(); // testsuites
            writer.WriteEndDocument();
        }
    }
}

public class TestQualityAnalyzer
{
    private readonly TestDiscoverer _discoverer = new TestDiscoverer();
    
    public TestQualityReport AnalyzeTestQuality(Assembly testAssembly, Assembly targetAssembly)
    {
        var testClasses = _discoverer.DiscoverTests(testAssembly);
        var report = new TestQualityReport();
        
        // Анализ покрытия методов
        report.MethodCoverage = AnalyzeMethodCoverage(testClasses, targetAssembly);
        
        // Анализ разнообразия проверок
        report.AssertionDiversity = AnalyzeAssertionDiversity(testClasses);
        
        // Анализ тестирования исключений
        report.ExceptionTesting = AnalyzeExceptionTesting(testClasses);
        
        // Анализ параметризации тестов
        report.ParameterizationScore = AnalyzeParameterization(testClasses);
        
        return report;
    }
    
    private float AnalyzeMethodCoverage(List<TestInfo> testClasses, Assembly targetAssembly)
    {
        // Число публичных методов в целевой сборке
        var targetMethods = targetAssembly.GetTypes()
            .SelectMany(t => t.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
            .Where(m => !m.IsSpecialName) // Исключаем геттеры/сеттеры свойств
            .Count();
            
        if (targetMethods == 0)
            return 0;
        
        // Собираем все методы, вызываемые в тестах
        var calledMethods = new HashSet<string>();
        
        foreach (var test in testClasses)
        {
            var type = test.Type;
            // Анализируем IL-код тестового класса для выявления вызовов методов
            // Это сложная задача, которая требует использования специализированных 
            // библиотек типа Mono.Cecil для декомпиляции IL
            
            // В упрощенном виде можно использовать простой анализ строк в исходном коде
            // Но это не точный подход
        }
        
        // В реальном проекте здесь был бы более сложный алгоритм
        // Для примера возвращаем фиктивные данные
        return 0.75f;
    }
    
    private float AnalyzeAssertionDiversity(List<TestInfo> testClasses)
    {
        var assertionTypes = new HashSet<string>();
        int totalAssertions = 0;
        
        foreach (var test in testClasses)
        {
            var type = test.Type;
            // Аналогично, в реальном коде здесь был бы анализ 
            // использованных типов ассертов
        }
        
        // Коэффициент разнообразия: количество разных типов ассертов 
        // относительно общего числа ассертов
        return totalAssertions > 0 ? (float)assertionTypes.Count / totalAssertions : 0;
    }
    
    private float AnalyzeExceptionTesting(List<TestInfo> testClasses)
    {
        int testsWithExceptionHandling = 0;
        
        foreach (var test in testClasses)
        {
            var type = test.Type;
            // Проверка использования конструкций обработки исключений
            // и специальных методов типа ExceptionAssert.Throws
        }
        
        return testClasses.Count > 0 ? (float)testsWithExceptionHandling / testClasses.Count : 0;
    }
    
    private float AnalyzeParameterization(List<TestInfo> testClasses)
    {
        int parameterizedTests = 0;
        
        foreach (var test in testClasses)
        {
            if (typeof(ParameterizedTestCase<>).IsAssignableFrom(test.Type))
                parameterizedTests++;
        }
        
        return testClasses.Count > 0 ? (float)parameterizedTests / testClasses.Count : 0;
    }
}
 
public class TestQualityReport
{
    public float MethodCoverage { get; set; }
    public float AssertionDiversity { get; set; }
    public float ExceptionTesting { get; set; }
    public float ParameterizationScore { get; set; }
    
    public float OverallScore => (MethodCoverage + AssertionDiversity + ExceptionTesting + ParameterizationScore) / 4;
    
    public override string ToString()
    {
        return $"Отчет о качестве тестов:\n" +
               $"- Покрытие методов: {MethodCoverage:P1}\n" +
               $"- Разноообразие проверок: {AssertionDiversity:P1}\n" +
               $"- Тестирование исключений: {ExceptionTesting:P1}\n" +
               $"- Использование параметризации: {ParameterizationScore:P1}\n" +
               $"- Общая оценка: {OverallScore:P1}";
    }
}

public class TestingPlatform
{
    private readonly TestRunner _runner;
    private readonly CoverageRunner _coverageRunner;
    private readonly TestQualityAnalyzer _qualityAnalyzer;
    
    public TestingPlatform(string testAssemblyPath, string targetAssemblyPath)
    {
        _runner = new ParallelTestRunner();
        _coverageRunner = new CoverageRunner("coverage-tool.exe", targetAssemblyPath);
        _qualityAnalyzer = new TestQualityAnalyzer();
        
        // Загружаем сборки
        var testAssembly = Assembly.LoadFrom(testAssemblyPath);
        var targetAssembly = Assembly.LoadFrom(targetAssemblyPath);
        
        // Обнаруживаем и регистрируем тесты
        var discoverer = new TestDiscoverer();
        var testInfos = discoverer.DiscoverTests(testAssembly);
        
        foreach (var testInfo in testInfos)
        {
            var test = discoverer.CreateTestInstance(testInfo.Type);
            _runner.AddTest(test);
        }
    }
    
    public TestingPlatformReport RunTestSuite()
    {
        // Запускаем тесты и собираем результаты
        _runner.RunAll();
        var testResults = _runner.GetResults();
        
        // Запускаем анализ покрытия
        _coverageRunner.RunAll();
        
        // Анализируем качество тестов
        var testAssembly = Assembly.LoadFrom(testAssemblyPath);
        var targetAssembly = Assembly.LoadFrom(targetAssemblyPath);
        var qualityReport = _qualityAnalyzer.AnalyzeTestQuality(testAssembly, targetAssembly);
        
        // Генерируем комплексный отчет
        var report = new TestingPlatformReport
        {
            TestResults = testResults,
            QualityReport = qualityReport,
            CoverageReportPath = "coverage.xml"
        };
        
        // Создаем HTML-отчет
        var htmlReporter = new EnhancedHtmlReporter("test-report.html", "coverage.xml");
        htmlReporter.GenerateReport(testResults, qualityReport);
        
        return report;
    }
}
 
public class TestingPlatformReport
{
    public List<TestResult> TestResults { get; set; }
    public TestQualityReport QualityReport { get; set; }
    public string CoverageReportPath { get; set; }
    
    public bool IsSuccessful => TestResults.All(r => r.IsSuccess);
    
    public override string ToString()
    {
        var builder = new StringBuilder();
        builder.AppendLine("Отчет о выполнении тестов:");
        builder.AppendLine($"- Всего тестов: {TestResults.Count}");
        builder.AppendLine($"- Успешных: {TestResults.Count(r => r.IsSuccess)}");
        builder.AppendLine($"- Проваленных: {TestResults.Count(r => !r.IsSuccess)}");
        builder.AppendLine();
        builder.AppendLine(QualityReport.ToString());
        
        return builder.ToString();
    }
}
 
public class EnhancedHtmlReporter
{
    private readonly string _outputPath;
    private readonly string _coveragePath;
    
    public EnhancedHtmlReporter(string outputPath, string coveragePath = null)
    {
        _outputPath = outputPath;
        _coveragePath = coveragePath;
    }
    
    public void GenerateReport(List<TestResult> results, TestQualityReport qualityReport)
    {
        var sb = new StringBuilder();
        sb.AppendLine("<!DOCTYPE html>");
        sb.AppendLine("<html>");
        sb.AppendLine("<head>");
        sb.AppendLine("  <title>Комплексный отчет о тестировании</title>");
        sb.AppendLine("  <style>");
        sb.AppendLine("    .success { color: green; }");
        sb.AppendLine("    .failure { color: red; }");
        sb.AppendLine("    .skipped { color: gray; }");
        sb.AppendLine("    .quality-high { background-color: #d4edda; }");
        sb.AppendLine("    .quality-medium { background-color: #fff3cd; }");
        sb.AppendLine("    .quality-low { background-color: #f8d7da; }");
        sb.AppendLine("    table { border-collapse: collapse; width: 100%; }");
        sb.AppendLine("    th, td { border: 1px solid #ddd; padding: 8px; }");
        sb.AppendLine("    tr:nth-child(even) { background-color: #f2f2f2; }");
        sb.AppendLine("    .report-section { margin-bottom: 30px; }");
        sb.AppendLine("  </style>");
        sb.AppendLine("</head>");
        sb.AppendLine("<body>");
        
        // Раздел с общей статистикой
        sb.AppendLine("<div class='report-section'>");
        sb.AppendLine("  <h1>Комплексный отчет о тестировании</h1>");
        int total = results.Count;
        int passed = results.Count(r => r.IsSuccess);
        int failed = results.Count(r => !r.IsSuccess);
        
        sb.AppendLine("  <div class='summary'>");
        sb.AppendLine($"    <p>Всего тестов: {total}</p>");
        sb.AppendLine($"    <p class='success'>Успешных: {passed}</p>");
        sb.AppendLine($"    <p class='failure'>Проваленных: {failed}</p>");
        sb.AppendLine("  </div>");
        sb.AppendLine("</div>");
        
        // Раздел с качеством тестов
        sb.AppendLine("<div class='report-section'>");
        sb.AppendLine("  <h2>Оценка качества тестов</h2>");
        
        string qualityClass = qualityReport.OverallScore > 0.7f ? "quality-high" :
                             qualityReport.OverallScore > 0.4f ? "quality-medium" : "quality-low";
        
        sb.AppendLine($"  <div class='{qualityClass}'>");
        sb.AppendLine($"    <p>Общая оценка: {qualityReport.OverallScore:P1}</p>");
        sb.AppendLine($"    <p>Покрытие методов: {qualityReport.MethodCoverage:P1}</p>");
        sb.AppendLine($"    <p>Разнообразие проверок: {qualityReport.AssertionDiversity:P1}</p>");
        sb.AppendLine($"    <p>Тестирование исключений: {qualityReport.ExceptionTesting:P1}</p>");
        sb.AppendLine($"    <p>Использование параметризации: {qualityReport.ParameterizationScore:P1}</p>");
        sb.AppendLine("  </div>");
        sb.AppendLine("</div>");
        
        // Добавляем таблицу с результатами тестов
        sb.AppendLine("<div class='report-section'>");
        sb.AppendLine("  <h2>Результаты выполнения тестов</h2>");
        sb.AppendLine("  <table>");
        sb.AppendLine("    <tr>");
        sb.AppendLine("      <th>Тест</th>");
        sb.AppendLine("      <th>Статус</th>");
        sb.AppendLine("      <th>Время (мс)</th>");
        sb.AppendLine("      <th>Память (КБ)</th>");
        sb.AppendLine("      <th>Сообщение</th>");
        sb.AppendLine("    </tr>");
        
        foreach (var result in results)
        {
            string statusClass = result.IsSuccess ? "success" : "failure";
            
            sb.AppendLine("    <tr>");
            sb.AppendLine($"      <td>{result.TestName}</td>");
            sb.AppendLine($"      <td class='{statusClass}'>{(result.IsSuccess ? "Успех" : "Провал")}</td>");
            sb.AppendLine($"      <td>{result.Metrics.ExecutionTime.TotalMilliseconds:F1}</td>");
            sb.AppendLine($"      <td>{result.Metrics.MemoryUsedBytes / 1024:F1}</td>");
            sb.AppendLine($"      <td>{(result.IsSuccess ? "" : result.FailureMessage)}</td>");
            sb.AppendLine("    </tr>");
        }
        
        sb.AppendLine("  </table>");
        sb.AppendLine("</div>");
        
        // Если есть информация о покрытии, добавляем её
        if (File.Exists(_coveragePath))
        {
            sb.AppendLine("<div class='report-section'>");
            sb.AppendLine("  <h2>Покрытие кода</h2>");
            
            // Здесь мы бы добавили визуализацию покрытия кода,
            // например, в виде тепловой карты или графика
            
            sb.AppendLine("</div>");
        }
        
        sb.AppendLine("</body>");
        sb.AppendLine("</html>");
        
        File.WriteAllText(_outputPath, sb.ToString());
    }
}