ThreadingWpfTests.cs

이 파일의 문서화 페이지로 가기

using System.Globalization;
using System.Windows.Data;
using System.Windows.Media;
using Dreamine.Threading.Models;
using Dreamine.Threading.Interfaces;
using Dreamine.Threading.Windows.Services;
using Dreamine.Threading.Wpf.Converters;
using Dreamine.Threading.Wpf.Services;
using Dreamine.Threading.Wpf.ViewModels;
using System.Windows.Threading;
 
namespace Dreamine.FullKit.Wpf.Tests.Threading;

public sealed class ThreadingWpfTests
{
    [Fact]
    public void ThreadConverters_MapKnownValues()
    {
        var statusConverter = new ThreadStatusBrushConverter();
        var priorityConverter = new ThreadPriorityTextConverter();
 
        Assert.Same(Brushes.ForestGreen, statusConverter.Convert(DreamineThreadStatus.Running, typeof(Brush), null!, CultureInfo.InvariantCulture));
        Assert.Same(Brushes.Crimson, statusConverter.Convert(DreamineThreadStatus.Faulted, typeof(Brush), null!, CultureInfo.InvariantCulture));
        Assert.Same(Brushes.Gray, statusConverter.Convert("bad", typeof(Brush), null!, CultureInfo.InvariantCulture));
        Assert.Equal("High", priorityConverter.Convert(DreamineThreadPriority.High, typeof(string), null!, CultureInfo.InvariantCulture));
        Assert.Equal(string.Empty, priorityConverter.Convert("bad", typeof(string), null!, CultureInfo.InvariantCulture));
        Assert.Same(Binding.DoNothing, priorityConverter.ConvertBack("", typeof(DreamineThreadPriority), null!, CultureInfo.InvariantCulture));
    }

    [Fact]
    public void ThreadInfoRow_UpdatesChangedFieldsAndDerivedFlags()
    {
        var row = new ThreadInfoRow(CreateInfo(DreamineThreadStatus.Created, cycles: 1));
        var changed = new List<string?>();
        row.PropertyChanged += (_, args) => changed.Add(args.PropertyName);
 
        var updated = row.UpdateFrom(CreateInfo(DreamineThreadStatus.Running, cycles: 2));
 
        Assert.True(updated);
        Assert.Equal(DreamineThreadStatus.Running, row.Status);
        Assert.True(row.IsRunning);
        Assert.Contains(nameof(ThreadInfoRow.Status), changed);
        Assert.Contains(nameof(ThreadInfoRow.CycleCount), changed);
        Assert.Contains(nameof(ThreadInfoRow.IsRunning), changed);
    }

    [Fact]
    public void WindowsCpuInfoProvider_ReportsValidProcessorRange()
    {
        ICpuInfoProvider provider = new WindowsCpuInfoProvider();
 
        Assert.True(provider.GetLogicalProcessorCount() >= 1);
        Assert.True(provider.IsValidCoreIndex(0));
        Assert.False(provider.IsValidCoreIndex(-1));
        Assert.False(provider.IsValidCoreIndex(provider.GetLogicalProcessorCount()));
    }

    [Fact]
    public void ThreadMonitorViewModel_AcceptsDispatcherAbstraction()
    {
        using var viewModel = new DreamineThreadMonitorViewModel(
            new TestThreadManager(),
            new TestThreadUiDispatcher(),
            TimeSpan.FromSeconds(1));
 
        Assert.Empty(viewModel.Threads);
    }

    private static DreamineThreadInfo CreateInfo(DreamineThreadStatus status, long cycles)
    {
        return new DreamineThreadInfo(
            "Worker",
            status,
            DreamineThreadPriority.Normal,
            intervalMs: 10,
            coreIndex: null,
            useAffinity: false,
            jobCount: 1,
            cycleCount: cycles,
            startedAt: null,
            stoppedAt: null,
            lastErrorMessage: null);
    }

    private sealed class TestThreadUiDispatcher : IThreadUiDispatcher
    {
        public Dispatcher Dispatcher { get; } = Dispatcher.CurrentDispatcher;

        public void Invoke(Action action)
        {
            action();
        }

        public void BeginInvoke(Action action)
        {
            action();
        }
    }

    private sealed class TestThreadManager : IDreamineThreadManager
    {
        public IDreamineThreadJob Register(DreamineThreadOptions options, Func<CancellationToken, ValueTask> action)
        {
            throw new NotSupportedException();
        }

        public bool Start(string threadName) => true;

        public bool Stop(string threadName) => true;

        public ValueTask<bool> StopAsync(string threadName) => ValueTask.FromResult(true);

        public bool Pause(string threadName) => true;

        public bool Resume(string threadName) => true;

        public void StartAll()
        {
        }

        public void StopAll()
        {
        }

        public ValueTask StopAllAsync() => ValueTask.CompletedTask;

        public void PauseAll()
        {
        }

        public void ResumeAll()
        {
        }

        public bool TryGetThread(string threadName, out IDreamineThread? thread)
        {
            thread = null;
            return false;
        }

        public IReadOnlyList<IDreamineThread> GetThreads() => Array.Empty<IDreamineThread>();

        public IReadOnlyList<DreamineThreadInfo> GetThreadInfos() => Array.Empty<DreamineThreadInfo>();

        public void Dispose()
        {
        }
    }
}