借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
13.27 KiB
XCoder
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using NewLife.XCoder.Tools.Folder;

namespace XCoder.App.Tests;

/// <summary>磁盘扫描器测试</summary>
public class DiskScannerTests : IDisposable
{
    private readonly String _cacheDir = Path.Combine(Path.GetTempPath(), "xcoder-cache-" + Guid.NewGuid().ToString("N"));

    /// <summary>清理测试缓存</summary>
    public void Dispose()
    {
        try { if (Directory.Exists(_cacheDir)) Directory.Delete(_cacheDir, true); } catch { }
    }

    private DiskScanner CreateScanner() => new() { CacheDirectory = _cacheDir };

    [Fact]
    [DisplayName("扫描结果与 FolderScanner 完全一致")]
    public async Task Scan_MatchesFolderScanner()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);

            var expected = FolderScanner.Scan(root);
            Assert.Equal(expected.TotalSize, volume.Size);
            Assert.Equal(expected.TotalFiles, volume.FileCount);
            Assert.Equal(expected.TotalDirectories, volume.DirCount);
            Assert.True(volume.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("按层加载立即给出文件与子目录")]
    public async Task LoadLevel_ListsEntries()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);

            Assert.True(volume.IsLoaded);
            Assert.Equal(2, volume.Files.Count);
            Assert.Equal(2, volume.Children.Count);
            Assert.Equal(150, volume.OwnSize);
            Assert.False(volume.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("扫描进度单调递增并最终等于总量")]
    public async Task Scan_ProgressMonotonic()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        var sizes = new ConcurrentQueue<Int64>();
        scanner.Changed += (s, e) => sizes.Enqueue(scanner.Progress.Size);

        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);

            var list = sizes.ToArray();
            Assert.NotEmpty(list);
            for (var i = 1; i < list.Length; i++)
            {
                Assert.True(list[i] >= list[i - 1], $"进度回退:{list[i - 1]} -> {list[i]}");
            }

            Assert.Equal(volume.Size, list[^1]);
            Assert.Equal(175, list[^1]);
            Assert.True(scanner.Progress.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("重复加载与扫描不会重复累计")]
    public async Task Scan_Twice_DoesNotDoubleCount()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);
            var first = volume.Size;

            await scanner.LoadLevelAsync(volume);
            await scanner.ScanAsync(volume);

            Assert.Equal(first, volume.Size);
            Assert.Equal(175, volume.Size);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("重置后重新扫描恢复同样结果")]
    public async Task Reset_ThenRescan()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);
            Assert.Equal(175, volume.Size);

            await scanner.ResetAsync(volume);
            Assert.Equal(0, volume.Size);
            Assert.False(volume.IsLoaded);
            Assert.Empty(volume.Children);

            await scanner.LoadLevelAsync(volume);
            await scanner.ScanAsync(volume);

            Assert.Equal(175, volume.Size);
            Assert.True(volume.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("汇总包含扩展名分布与最大文件")]
    public async Task Summary_ExtensionsAndLargest()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);

            var extensions = scanner.Summary.GetExtensions();
            Assert.Contains(extensions, e => e.Extension == ".txt" && e.Size == 100);
            Assert.Contains(extensions, e => e.Extension == ".bin" && e.Size == 25);

            var largest = scanner.Summary.GetLargestFiles();
            Assert.NotEmpty(largest);
            Assert.EndsWith("a.txt", largest[0].Path);
            Assert.Equal(100, largest[0].Size);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("进入已完成目录后仍能列出子树最大文件")]
    public async Task LargestFiles_PerNode_SurviveCompletedNavigation()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume, 4);

            var volumeTop = volume.GetLargestFiles();
            Assert.Equal(3, volumeTop.Count);
            Assert.EndsWith("a.txt", volumeTop[0].Path);
            Assert.Equal(100, volumeTop[0].Size);
            Assert.EndsWith("b.log", volumeTop[1].Path);
            Assert.EndsWith("c.bin", volumeTop[2].Path);
            Assert.Equal(25, volumeTop[2].Size);

            // 界面进入已完成的子目录:LoadLevel 重新枚举后,扫描器对已完成节点直接返回,
            // 最大文件必须仍然来自节点自身记录,而不是被清空的本轮扫描汇总
            var sub = volume.Children.First(e => e.Name == "sub");
            await scanner.LoadLevelAsync(sub);
            await scanner.ScanAsync(sub);
            Assert.True(sub.IsComplete);

            var subTop = sub.GetLargestFiles();
            var only = Assert.Single(subTop);
            Assert.EndsWith("c.bin", only.Path);
            Assert.Equal(25, only.Size);
            Assert.Empty(volume.Children.First(e => e.Name == "empty").GetLargestFiles());
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("取消令牌立即生效")]
    public async Task LoadLevel_CanceledToken_Throws()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);

            await Assert.ThrowsAnyAsync<OperationCanceledException>(
                () => scanner.LoadLevelAsync(volume, new CancellationToken(true)));
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("隐藏文件也计入统计")]
    public async Task Scan_IncludesHiddenFiles()
    {
        if (!OperatingSystem.IsWindows()) return;

        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var hidden = Path.Combine(root, "hidden.tmp");
            File.WriteAllBytes(hidden, new Byte[7]);
            File.SetAttributes(hidden, FileAttributes.Hidden);

            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);

            Assert.Equal(182, volume.Size);
            Assert.Equal(4, volume.FileCount);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("空目录扫描后立即完成")]
    public async Task Scan_EmptyDirectory_Completes()
    {
        var root = Path.Combine(Path.GetTempPath(), "xcoder-empty-" + Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(root);

        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume);

            Assert.True(volume.IsComplete);
            Assert.Equal(0, volume.Size);
            Assert.Equal(0, volume.FileCount);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("缓存目录按缓存分类着色")]
    public void CachedNode_UsesCachedDominantCategory()
    {
        var node = DiskNode.CreateDirectory("cache", Path.Combine(Path.GetTempPath(), "xcoder-cat"), null);
        var categories = new Int64[FileCategoryHelper.Count];
        categories[(Int32)FileCategory.Video] = 100;

        node.ApplyCacheHint(100, 1, 0, categories);

        Assert.Equal(FileCategory.Video, node.DominantCategory);
    }

    [Fact]
    [DisplayName("并行枚举与单线程结果一致")]
    public async Task Scan_Parallel_MatchesSingleThread()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume, 4);

            var expected = FolderScanner.Scan(root);
            Assert.Equal(expected.TotalSize, volume.Size);
            Assert.Equal(expected.TotalFiles, volume.FileCount);
            Assert.Equal(expected.TotalDirectories, volume.DirCount);
            Assert.True(volume.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("先列条目再套缓存大小,最后复核更新")]
    public async Task Cache_ReusesLastSizes_ThenRescans()
    {
        var root = CreateTempTree();
        try
        {
            using (var first = CreateScanner())
            {
                var volume = await LoadVolumeAsync(first, root);
                await first.ScanAsync(volume, 4);
                Assert.Equal(175, volume.Size);
            }

            using var second = CreateScanner();
            var cached = await LoadVolumeAsync(second, root);
            var sub = cached.Children.First(e => e.Name == "sub");

            // 第一帧只来自实时枚举,缓存尚未读取
            Assert.False(cached.HasCache);
            Assert.False(sub.HasCache);

            await second.ApplyCacheAsync(cached);
            Assert.True(sub.HasCache);
            Assert.Equal(25, sub.CachedSize);
            Assert.Equal(25, sub.DisplaySize);
            Assert.Equal(175, cached.CachedSize);

            await second.ScanAsync(cached, 4);
            Assert.Equal(175, cached.Size);
            Assert.True(cached.IsComplete);
            Assert.True(sub.IsComplete);
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    [Fact]
    [DisplayName("删除节点后从父级扣减大小与计数")]
    public async Task RemoveNode_UpdatesAncestors()
    {
        var root = CreateTempTree();
        using var scanner = CreateScanner();
        try
        {
            var volume = await LoadVolumeAsync(scanner, root);
            await scanner.ScanAsync(volume, 4);

            var sub = volume.Children.First(e => e.Name == "sub");
            var size = sub.Size;
            var before = volume.Size;
            var dirs = volume.DirCount;

            Assert.True(scanner.RemoveNode(sub));
            Assert.Equal(before - size, volume.Size);
            Assert.Equal(dirs - 1, volume.DirCount);
            Assert.Equal(150, volume.OwnSize);
            Assert.DoesNotContain(volume.Children, e => ReferenceEquals(e, sub));

            var file = volume.Files.First(e => e.Name == "a.txt");
            var files = volume.FileCount;
            Assert.True(scanner.RemoveNode(file));
            Assert.Equal(files - 1, volume.FileCount);
            Assert.Equal(before - size - 100, volume.Size);
            Assert.Equal(50, volume.OwnSize);
            Assert.DoesNotContain(volume.Files, e => ReferenceEquals(e, file));
        }
        finally
        {
            Directory.Delete(root, true);
        }
    }

    private static async Task<DiskNode> LoadVolumeAsync(DiskScanner scanner, String root)
    {
        var tree = scanner.BuildTree([new FolderDrive(root, "", 0, 0, true)]);
        var volume = tree.Children[0];
        await scanner.LoadLevelAsync(volume);
        return volume;
    }

    private static String CreateTempTree()
    {
        var root = Path.Combine(Path.GetTempPath(), "xcoder-disk-" + Guid.NewGuid().ToString("N"));
        Directory.CreateDirectory(root);
        Directory.CreateDirectory(Path.Combine(root, "sub"));
        Directory.CreateDirectory(Path.Combine(root, "empty"));

        File.WriteAllBytes(Path.Combine(root, "a.txt"), new Byte[100]);
        File.WriteAllBytes(Path.Combine(root, "b.log"), new Byte[50]);
        File.WriteAllBytes(Path.Combine(root, "sub", "c.bin"), new Byte[25]);

        return root;
    }
}