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;
}
}
|