Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

29.4 KB
Raw Blame
// Archive engine: conversions between archive formats (names incl. Korean, folders, contents and times survive),
// Extract to a folder, "Compress into one archive", Filee's own ALZ / EGG / lzip / bzip2 readers, and the safety
// checks (zip slip, links, passwords). Tests that need the bundled 7-Zip skip when engines/7zip is missing
// (pwsh build/fetch-engines.ps1 -Only 7zip).

using System.Formats.Tar;
using System.IO.Compression;
using System.Text;
using Filee.Core.Conversion;
using Filee.Core.Formats;
using Filee.Core.Presets;
using Filee.Engines.Archives;
using static Filee.Engines.Tests.ArchiveBuilders;

namespace Filee.Engines.Tests;

public class ArchiveTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
    private static CancellationToken Ct => TestContext.Current.CancellationToken;

    private void SkipWithout7Zip()
    {
        var engine = fx.Converters.Single(c => c.Id == "archive");
        Assert.SkipUnless(fx.Catalog.StatusOf(engine).IsAvailable, "7-Zip not found (pwsh build/fetch-engines.ps1 -Only 7zip)");
    }

    private async Task<ConversionJob> ConvertOkAsync(string source, Preset preset)
    {
        var job = await fx.ConvertAsync([source], preset);
        Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => $"{f.ErrorKey} {f.ErrorDetail}")));
        return job;
    }

    private static Preset Extract => BuiltInData.CreatePresets().Single(p => p.Id == "extract");

    // ───────── Routes ─────────

    [Theory]
    [InlineData("zip")]
    [InlineData("jar")]
    [InlineData("7z")]
    [InlineData("rar")]
    [InlineData("tgz")]
    [InlineData("tbz2")]
    [InlineData("txz")]
    [InlineData("tar7z")]
    [InlineData("tz")]
    [InlineData("iso")]
    [InlineData("dmg")]
    [InlineData("cab")]
    [InlineData("rpm")]
    [InlineData("deb")]
    [InlineData("lha")]
    [InlineData("arj")]
    [InlineData("alz")]
    [InlineData("egg")]
    [InlineData("lz")]
    [InlineData("tlz")]
    [InlineData("split")]
    public void Every_readable_archive_converts_in_one_step(string from)
    {
        var planner = fx.Catalog.CreatePlanner(["archive"]);
        foreach (var to in new[] { "zip", "7z", "tar", "tgz", "tbz2", "txz", FormatRegistry.Folder })
        {
            var route = planner.Plan(from, to);
            Assert.NotNull(route);
            Assert.Equal("archive", Assert.Single(route.Steps).Converter.Id);
        }
    }

    [Fact]
    public void Single_file_compressors_convert_among_each_other_but_archives_do_not_shrink_to_them()
    {
        var planner = fx.Catalog.CreatePlanner(["archive"]);
        Assert.Single(planner.Plan("gz", "xz")!.Steps);
        Assert.Single(planner.Plan("lzma", "bz2")!.Steps);
        Assert.Single(planner.Plan("lz", "gz")!.Steps);
        Assert.Null(planner.Plan("zip", "gz"));  // several files do not fit into one .gz
        Assert.Null(planner.Plan("zip", "rar")); // RAR cannot be written
        Assert.Null(planner.Plan("lzo", "zip")); // no LZO reader
        // Every format the edges name exists in the registry.
        foreach (var edge in fx.Converters.Single(c => c.Id == "archive").Edges)
        {
            Assert.NotNull(FormatRegistry.FindById(edge.From));
            Assert.NotNull(FormatRegistry.FindById(edge.To));
        }
    }

    // ───────── Archive → archive ─────────

    [Fact]
    public async Task Zip_7z_tgz_tar_zip_round_trip_keeps_names_folders_contents_and_times()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var tree = MakeTree(dir, "프로젝트");
        var expected = Snapshot(tree);
        var zip = Path.Combine(dir, "프로젝트.zip");
        ZipFile.CreateFromDirectory(tree, zip, CompressionLevel.Optimal, includeBaseDirectory: true, Encoding.UTF8);

        var current = zip;
        foreach (var target in new[] { "7z", "tgz", "tar", "tbz2", "txz", "zip" })
        {
            var job = await ConvertOkAsync(current, new Preset { TargetFormat = target });
            current = job.Outputs.Single();
            Assert.EndsWith("." + FormatRegistry.Get(target).PrimaryExtension, current);
        }

        // The last ZIP read by .NET's own reader: same tree below the "프로젝트" folder, UTF-8 names flagged.
        var check = Path.Combine(dir, "check");
        ZipFile.ExtractToDirectory(current, check);
        Assert.Equal(expected, Snapshot(Path.Combine(check, "프로젝트")));
        var time = File.GetLastWriteTime(Path.Combine(check, "프로젝트", "readme.txt"));
        // 7-Zip turns a ZIP's local times into UTC with Windows' current offset, which in a time zone with daylight
        // saving time can be an hour off .NET's offset for that date (seen on a Pacific-time CI runner).
        var off = Math.Abs((time - KnownTime).TotalSeconds);
        var dstHour = TimeZoneInfo.Local.SupportsDaylightSavingTime && Math.Abs(off - 3600) <= 2;
        Assert.True(off <= 2 || dstHour, $"time {time} instead of {KnownTime}");
    }

    [Fact]
    public async Task Store_and_maximum_levels_are_applied()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var text = Path.Combine(dir, "big.txt");
        await File.WriteAllBytesAsync(text, Words(300_000), Ct);
        var source = Path.Combine(dir, "source.zip");
        using (var zip = ZipFile.Open(source, ZipArchiveMode.Create))
            zip.CreateEntryFromFile(text, "big.txt");

        var stored = await ConvertOkAsync(source, new Preset { TargetFormat = "7z", Archive = { Level = ArchiveLevel.Store }, Output = { FileNamePattern = "{name}_store" } });
        var max = await ConvertOkAsync(source, new Preset { TargetFormat = "7z", Archive = { Level = ArchiveLevel.Maximum }, Output = { FileNamePattern = "{name}_max" } });
        Assert.True(new FileInfo(stored.Outputs.Single()).Length > 300_000);
        Assert.True(new FileInfo(max.Outputs.Single()).Length < 100_000);
    }

    [Fact]
    public async Task Single_file_streams_convert_gz_xz_bz2()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var data = Words(50_000);
        var csv = Path.Combine(dir, "data.csv");
        await File.WriteAllBytesAsync(csv, data, Ct);
        var gz = Path.Combine(dir, "data.csv.gz");
        await Run7zAsync("a", "-tgzip", gz, csv);
        File.Delete(csv);

        var xz = (await ConvertOkAsync(gz, new Preset { TargetFormat = "xz" })).Outputs.Single();
        var bz2 = (await ConvertOkAsync(xz, new Preset { TargetFormat = "bz2" })).Outputs.Single();
        Assert.EndsWith("data.csv.bz2", bz2);

        var folder = (await ConvertOkAsync(bz2, Extract)).Outputs.Single();
        Assert.Equal(data, await File.ReadAllBytesAsync(Path.Combine(folder, "data.csv"), Ct));
    }

    // ───────── Extract ─────────

    [Fact]
    public async Task Extract_does_not_nest_a_single_top_folder_and_renames_on_conflict()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var tree = MakeTree(dir, "photos");
        var expected = Snapshot(tree);
        var zip = Path.Combine(dir, "사진.zip");
        ZipFile.CreateFromDirectory(tree, zip, CompressionLevel.Fastest, includeBaseDirectory: true, Encoding.UTF8);
        Directory.Delete(tree, true);

        var first = await ConvertOkAsync(zip, Extract);
        var folder = first.Outputs.Single();
        Assert.Equal(Path.Combine(dir, "사진"), folder);
        Assert.Equal(expected, Snapshot(folder)); // photos/… became 사진/…, not 사진/photos/…

        var second = await ConvertOkAsync(zip, Extract);
        Assert.Equal(Path.Combine(dir, "사진 (2)"), second.Outputs.Single());
        Assert.Equal(expected, Snapshot(second.Outputs.Single()));

        // Nothing else was left next to the archive (no staging folders).
        Assert.Equal(["사진", "사진 (2)", "사진.zip"], Directory.GetFileSystemEntries(dir).Select(Path.GetFileName).Order(StringComparer.Ordinal));
    }

    [Fact]
    public async Task Extract_keeps_several_top_entries_in_a_folder_named_after_the_archive_and_unpacks_tar_gz_fully()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var tree = MakeTree(dir, "tree");
        var tgz = Path.Combine(dir, "backup.tar.gz");
        await using (var file = File.Create(tgz))
        await using (var gzip = new GZipStream(file, CompressionLevel.Fastest))
            await TarFile.CreateFromDirectoryAsync(tree, gzip, includeBaseDirectory: false, Ct);

        var folder = (await ConvertOkAsync(tgz, Extract)).Outputs.Single();
        Assert.Equal(Path.Combine(dir, "backup"), folder);
        Assert.Equal(Snapshot(tree), Snapshot(folder)); // files, not a lone backup.tar
    }

    [Fact]
    public async Task Split_archive_001_extracts_all_volumes()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var content = "This is a split multi-part archive test payload."u8.ToArray();
        var file = Path.Combine(dir, "document.txt");
        await File.WriteAllBytesAsync(file, content, Ct);
        var split7z = Path.Combine(dir, "split_archive.7z");
        await Run7zAsync("a", "-t7z", "-v20b", split7z, file);
        File.Delete(file);

        var firstPart = Path.Combine(dir, "split_archive.7z.001");
        Assert.True(File.Exists(firstPart));
        Assert.True(File.Exists(Path.Combine(dir, "split_archive.7z.002")));

        var folder = (await ConvertOkAsync(firstPart, Extract)).Outputs.Single();
        Assert.Equal(content, await File.ReadAllBytesAsync(Path.Combine(folder, "document.txt"), Ct));
    }

    [Fact]
    public async Task Extract_with_overwrite_merges_into_the_existing_folder_and_skip_leaves_it_alone()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var tree = MakeTree(dir, "data");
        var zip = Path.Combine(dir, "data.zip");
        ZipFile.CreateFromDirectory(tree, zip, CompressionLevel.Fastest, includeBaseDirectory: false, Encoding.UTF8);
        Directory.Delete(tree, true);
        var target = Directory.CreateDirectory(Path.Combine(dir, "data")).FullName;
        await File.WriteAllTextAsync(Path.Combine(target, "readme.txt"), "old", Ct);
        await File.WriteAllTextAsync(Path.Combine(target, "mine.txt"), "keep", Ct);

        var overwrite = Extract;
        overwrite.Output.Conflict = ConflictPolicy.Overwrite;
        Assert.Equal(target, (await ConvertOkAsync(zip, overwrite)).Outputs.Single());
        Assert.Equal("Filee archive test\n", await File.ReadAllTextAsync(Path.Combine(target, "readme.txt"), Ct));
        Assert.Equal("keep", await File.ReadAllTextAsync(Path.Combine(target, "mine.txt"), Ct));
        Assert.True(File.Exists(Path.Combine(target, "docs", "보고서", "data.csv")));

        var skip = Extract;
        skip.Output.Conflict = ConflictPolicy.Skip;
        var skipped = await fx.ConvertAsync([zip], skip);
        Assert.Equal(FileState.Skipped, skipped.Files[0].State);
        Assert.Empty(skipped.Outputs);
    }

    [Fact]
    public async Task Tar_symbolic_links_are_not_unpacked()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var tar = Path.Combine(dir, "links.tar");
        await using (var stream = File.Create(tar))
        await using (var writer = new TarWriter(stream, TarEntryFormat.Pax))
        {
            await writer.WriteEntryAsync(new PaxTarEntry(TarEntryType.RegularFile, "real.txt") { DataStream = new MemoryStream("real"u8.ToArray()) }, Ct);
            await writer.WriteEntryAsync(new PaxTarEntry(TarEntryType.SymbolicLink, "escape") { LinkName = "../../../../Windows/win.ini" }, Ct);
            await writer.WriteEntryAsync(new PaxTarEntry(TarEntryType.SymbolicLink, "inside") { LinkName = "real.txt" }, Ct);
        }

        var folder = (await ConvertOkAsync(tar, Extract)).Outputs.Single();
        Assert.Equal(["real.txt"], Directory.GetFileSystemEntries(folder).Select(Path.GetFileName));
    }

    [Fact]
    public async Task Zip_slip_entries_are_rejected()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var inner = Directory.CreateDirectory(Path.Combine(dir, "inner")).FullName;
        var zip = Path.Combine(inner, "evil.zip");
        using (var archive = ZipFile.Open(zip, ZipArchiveMode.Create))
        {
            using (var w = new StreamWriter(archive.CreateEntry("good.txt").Open()))
                w.Write("good");
            using (var w = new StreamWriter(archive.CreateEntry("../../evil.txt").Open()))
                w.Write("evil");
        }

        var job = await fx.ConvertAsync([zip], Extract);

        Assert.Equal(JobState.Failed, job.State);
        Assert.Contains("outside the target folder", job.Files[0].ErrorDetail);
        Assert.False(File.Exists(Path.Combine(dir, "evil.txt")));
        Assert.Equal(["evil.zip"], Directory.GetFileSystemEntries(inner).Select(Path.GetFileName)); // no half-extracted folder
    }

    [Fact]
    public async Task Password_protected_archives_fail_with_a_clear_message()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var secret = Path.Combine(dir, "secret.txt");
        await File.WriteAllTextAsync(secret, "secret", Ct);
        var zip = Path.Combine(dir, "locked.zip");
        var sevenZip = Path.Combine(dir, "locked.7z");
        await Run7zAsync("a", "-tzip", "-ppassword", zip, secret);
        await Run7zAsync("a", "-t7z", "-ppassword", "-mhe=on", sevenZip, secret);

        foreach (var archive in new[] { zip, sevenZip })
        {
            var job = await fx.ConvertAsync([archive], new Preset { TargetFormat = "tgz" });
            Assert.Equal(JobState.Failed, job.State);
            Assert.Contains("password-protected", job.Files[0].ErrorDetail);
        }
    }

    [Fact]
    public async Task Damaged_and_fake_archives_fail_cleanly()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var fake = Path.Combine(dir, "fake.zip");
        await File.WriteAllTextAsync(fake, "this is not a zip", Ct);

        var job = await fx.ConvertAsync([fake], Extract);

        Assert.Equal(JobState.Failed, job.State);
        Assert.Contains("not a valid archive", job.Files[0].ErrorDetail);
        Assert.Equal(["fake.zip"], Directory.GetFileSystemEntries(dir).Select(Path.GetFileName));
    }

    // ───────── Compress into one archive ─────────

    [Fact]
    public async Task Zip_all_packs_any_files_as_they_are()
    {
        var dir = fx.NewFolder();
        var a = Directory.CreateDirectory(Path.Combine(dir, "a")).FullName;
        var b = Directory.CreateDirectory(Path.Combine(dir, "b")).FullName;
        var report = Path.Combine(a, "보고서.txt");
        await File.WriteAllTextAsync(report, "보고서", Ct);
        var unknown = Path.Combine(a, "data.xyz");
        await File.WriteAllBytesAsync(unknown, Noise(1000, 1), Ct);
        var image = EngineFixture.MakeImage(a, "photo.png", ImageMagick.MagickFormat.Png);
        var sameName = Path.Combine(b, "보고서.txt");
        await File.WriteAllTextAsync(sameName, "다른 보고서", Ct);

        var zipAll = BuiltInData.CreatePresets().Single(p => p.Id == "zip-all");
        var job = await fx.ConvertAsync([report, unknown, image, sameName], zipAll);

        Assert.Equal(JobState.Completed, job.State);
        var output = job.Outputs.Single();
        Assert.Equal(Path.Combine(a, "보고서_files.zip"), output);
        using var zip = ZipFile.OpenRead(output);
        Assert.Equal(["data.xyz", "photo.png", "보고서 (2).txt", "보고서.txt"], zip.Entries.Select(e => e.FullName).Order(StringComparer.Ordinal));
        using (var reader = new StreamReader(zip.GetEntry("보고서 (2).txt")!.Open()))
            Assert.Equal("다른 보고서", await reader.ReadToEndAsync(Ct));
        Assert.Equal(await File.ReadAllBytesAsync(image, Ct), ReadAll(zip.GetEntry("photo.png")!));
        Assert.True(File.Exists(report)); // sources untouched
    }

    [Fact]
    public async Task Zip_all_works_for_a_single_file_and_honours_the_level()
    {
        var dir = fx.NewFolder();
        var text = Path.Combine(dir, "notes.md");
        await File.WriteAllBytesAsync(text, Words(100_000), Ct);
        var preset = BuiltInData.CreatePresets().Single(p => p.Id == "zip-all");
        preset.Archive.Level = ArchiveLevel.Store;

        var job = await fx.ConvertAsync([text], preset);

        Assert.Equal(JobState.Completed, job.State);
        using var zip = ZipFile.OpenRead(job.Outputs.Single());
        var entry = Assert.Single(zip.Entries);
        Assert.Equal("notes.md", entry.Name);
        Assert.Equal(entry.Length, entry.CompressedLength);
    }

    [Fact]
    public async Task Zip_all_packs_a_folder_from_the_command_line_with_its_content()
    {
        var dir = fx.NewFolder();
        var tree = MakeTree(dir, "tree");

        var job = await fx.ConvertAsync([tree], BuiltInData.CreatePresets().Single(p => p.Id == "zip-all"));

        Assert.Equal(JobState.Completed, job.State);
        Assert.Equal(Path.Combine(dir, "tree_files.zip"), job.Outputs.Single());
        var check = Path.Combine(dir, "check");
        ZipFile.ExtractToDirectory(job.Outputs.Single(), check);
        Assert.Equal(Snapshot(tree), Snapshot(Path.Combine(check, "tree")));
    }

    [Theory]
    [InlineData("7z")]
    [InlineData("tgz")]
    [InlineData("txz")]
    public async Task Combine_into_other_archive_formats(string format)
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var one = Path.Combine(dir, "하나.txt");
        var two = Path.Combine(Directory.CreateDirectory(Path.Combine(dir, "sub")).FullName, "하나.txt");
        await File.WriteAllTextAsync(one, "1", Ct);
        await File.WriteAllTextAsync(two, "2", Ct);

        var job = await fx.ConvertAsync([one, two], new Preset { TargetFormat = format, Archive = { CombineIntoOne = true } });
        Assert.Equal(JobState.Completed, job.State);

        var folder = (await ConvertOkAsync(job.Outputs.Single(), Extract)).Outputs.Single();
        Assert.Equal("1", await File.ReadAllTextAsync(Path.Combine(folder, "하나.txt"), Ct));
        Assert.Equal("2", await File.ReadAllTextAsync(Path.Combine(folder, "하나 (2).txt"), Ct));
    }

    // ───────── Filee's own readers ─────────

    [Fact]
    public async Task Alz_with_stored_deflated_and_bzip2_entries_and_korean_names()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var big = Words(2_000_000); // three 900k bzip2 blocks
        var small = Encoding.UTF8.GetBytes("알집 테스트 ALZ");
        var alz = Path.Combine(dir, "알집.alz");
        WriteAlz(alz,
        [
            new("폴더\\", null),
            new("폴더\\저장.txt", small, Method: 0),
            new("압축.txt", Words(10_000), Method: 2),
            new("큰 파일.txt", big, Method: 1, Packed: ToAlzBzip2(await Bzip2Async(big, dir))),
        ]);

        var folder = (await ConvertOkAsync(alz, Extract)).Outputs.Single();

        Assert.Equal(small, await File.ReadAllBytesAsync(Path.Combine(folder, "폴더", "저장.txt"), Ct));
        Assert.Equal(Words(10_000), await File.ReadAllBytesAsync(Path.Combine(folder, "압축.txt"), Ct));
        Assert.Equal(big, await File.ReadAllBytesAsync(Path.Combine(folder, "큰 파일.txt"), Ct));
        Assert.Equal(KnownTime, File.GetLastWriteTime(Path.Combine(folder, "압축.txt")));

        var zip = (await ConvertOkAsync(alz, new Preset { TargetFormat = "zip" })).Outputs.Single();
        using var archive = ZipFile.OpenRead(zip);
        Assert.Contains(archive.Entries, e => e.FullName == "폴더/저장.txt");
    }

    [Fact]
    public void Alz_reader_refuses_escaping_and_encrypted_entries_without_writing_outside()
    {
        var dir = fx.NewFolder();
        var target = Directory.CreateDirectory(Path.Combine(dir, "out")).FullName;
        var slip = Path.Combine(dir, "slip.alz");
        WriteAlz(slip, [new("ok.txt", [1]), new("..\\..\\evil.txt", [2])]);
        var locked = Path.Combine(dir, "locked.alz");
        WriteAlz(locked, [new("secret.txt", [3], Encrypted: true)]);

        var error = Assert.Throws<InvalidDataException>(() => AlzReader.Extract(slip, target, Ct));
        Assert.Contains("outside the target folder", error.Message);
        Assert.False(File.Exists(Path.Combine(dir, "evil.txt")));
        Assert.Contains("password-protected", Assert.Throws<InvalidDataException>(() => AlzReader.Extract(locked, target, Ct)).Message);
    }

    [Fact]
    public async Task Egg_with_store_deflate_bzip2_lzma_and_multi_block_entries()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var text = Words(30_000);
        var part1 = Words(5_000);
        var part2 = Noise(7_000, 3);
        var egg = Path.Combine(dir, "에그.egg");
        WriteEgg(egg,
        [
            new("문서/", true),
            new("문서/stored.txt", false, new EggBlock(text, 0)),
            new("deflate.txt", false, new EggBlock(text, 1)),
            new("bzip2.txt", false, new EggBlock(text, 2, await Bzip2Async(text, dir))),
            new("lzma.txt", false, new EggBlock(text, 4, EggLzma(await RawLzmaAsync(text, endMarker: false, dir)))),
            new("두 블록.bin", false, new EggBlock(part1, 1), new EggBlock(part2, 0)),
        ]);

        var folder = (await ConvertOkAsync(egg, Extract)).Outputs.Single();

        foreach (var name in new[] { "문서/stored.txt", "deflate.txt", "bzip2.txt", "lzma.txt" })
            Assert.Equal(text, await File.ReadAllBytesAsync(Path.Combine(folder, name), Ct));
        byte[] joined = [.. part1, .. part2];
        Assert.Equal(joined, await File.ReadAllBytesAsync(Path.Combine(folder, "두 블록.bin"), Ct));
        Assert.Equal(KnownTime, File.GetLastWriteTime(Path.Combine(folder, "deflate.txt")));
    }

    [Fact]
    public async Task Solid_egg_archives_fail_with_a_clear_message()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var egg = Path.Combine(dir, "solid.egg");
        WriteEgg(egg, [new("a.txt", false, new EggBlock([1, 2, 3], 0))], solid: true);

        var job = await fx.ConvertAsync([egg], Extract);

        Assert.Equal(JobState.Failed, job.State);
        Assert.Contains("solid", job.Files[0].ErrorDetail);
    }

    [Fact]
    public async Task Lzip_files_and_tar_lz_are_unpacked()
    {
        SkipWithout7Zip();
        var dir = fx.NewFolder();
        var first = Words(40_000);
        var second = Noise(3_000, 9);
        var lz = Path.Combine(dir, "log.txt.lz");
        // Two members, as written by plzip or "cat a.lz b.lz".
        byte[] members = [.. await LzipAsync(first, dir), .. await LzipAsync(second, dir)];
        await File.WriteAllBytesAsync(lz, members, Ct);

        var folder = (await ConvertOkAsync(lz, Extract)).Outputs.Single();
        byte[] both = [.. first, .. second];
        Assert.Equal(both, await File.ReadAllBytesAsync(Path.Combine(folder, "log.txt"), Ct));

        var tree = MakeTree(dir, "tree");
        using var tar = new MemoryStream();
        await TarFile.CreateFromDirectoryAsync(tree, tar, includeBaseDirectory: false, Ct);
        var tarLz = Path.Combine(dir, "backup.tar.lz");
        await File.WriteAllBytesAsync(tarLz, await LzipAsync(tar.ToArray(), dir), Ct);

        var unpacked = (await ConvertOkAsync(tarLz, Extract)).Outputs.Single();
        Assert.Equal(Snapshot(tree), Snapshot(unpacked));
        var zip = (await ConvertOkAsync(tarLz, new Preset { TargetFormat = "zip" })).Outputs.Single();
        Assert.EndsWith("backup.zip", zip);
    }

    [Fact]
    public async Task Bzip2_decoder_reads_standard_multi_block_streams()
    {
        Assert.SkipUnless(SevenZipExe is not null, "7-Zip not found");
        var dir = fx.NewFolder();
        var data = Words(2_500_000);
        var bz2 = await Bzip2Async(data, dir);

        using var output = new MemoryStream();
        Bzip2Decoder.Decompress(new MemoryStream(bz2), output, alzFraming: false, long.MaxValue, Ct);
        Assert.Equal(data, output.ToArray());

        // A flipped bit is caught by the block checksum instead of producing wrong data.
        bz2[bz2.Length / 2] ^= 0x10;
        Assert.ThrowsAny<InvalidDataException>(() =>
        {
            Bzip2Decoder.Decompress(new MemoryStream(bz2), new MemoryStream(), alzFraming: false, long.MaxValue, Ct);
        });
    }

    // ───────── Helpers ─────────

    [Theory]
    [InlineData("../evil.txt", true)]
    [InlineData("a/../../evil.txt", true)]
    [InlineData("..\\evil.txt", true)]
    [InlineData("/etc/passwd", true)]
    [InlineData("\\abs.txt", true)]
    [InlineData("C:\\drive.txt", true)]
    [InlineData("a/b/c.txt", false)]
    [InlineData("한글/파일..txt", false)]
    public void Unsafe_entry_paths_are_recognised(string path, bool unsafePath) =>
        Assert.Equal(unsafePath, ArchiveSafety.IsUnsafePath(path));

    [Fact]
    public void Entry_names_are_made_valid_windows_names_inside_the_root()
    {
        var root = fx.NewFolder();
        Assert.Equal(Path.Combine(root, "폴더", "파일.txt"), ArchiveSafety.ResolveEntryPath(root, @"폴더\파일.txt", "x.alz"));
        Assert.Equal(Path.Combine(root, "a_b", "_CON.txt"), ArchiveSafety.ResolveEntryPath(root, "a|b/CON.txt", "x.alz"));
        Assert.Equal(Path.Combine(root, "file.txt_stream"), ArchiveSafety.ResolveEntryPath(root, "file.txt:stream", "x.alz")); // no NTFS streams
        Assert.Equal(Path.Combine(root, "dir", "file_"), ArchiveSafety.ResolveEntryPath(root, "./dir//file?", "x.alz"));
    }

    [Fact]
    public void Listing_parser_reads_7zip_technical_output()
    {
        const string output = """
            7-Zip 26.03 (x64)

            Listing archive: x.tar

            --
            Path = x.tar
            Type = tar

            ----------
            Path = dir\file.txt
            Folder = -
            Size = 7
            Mode = -rw-r--r--
            Symbolic Link =
            Hard Link =

            Path = dir\link
            Folder = -
            Size = 27
            Mode = lrw-r--r--
            Symbolic Link = ../../x
            Hard Link =

            Path = dir
            Folder = +
            Size = 0
            Encrypted = +

            """;
        var entries = SevenZip.ParseListing(output);
        Assert.Equal(["dir\\file.txt", "dir\\link", "dir"], entries.Select(e => e.Path));
        Assert.False(entries[0].IsSymbolicLink);
        Assert.True(entries[1].IsSymbolicLink);
        Assert.True(entries[2].IsFolder);
        Assert.True(entries[2].IsEncrypted);
        Assert.Equal(7, entries[0].Size);
    }

    [Fact]
    public void Clashing_names_in_one_archive_are_numbered()
    {
        var root = Path.GetTempPath();
        var items = ArchiveConverter.UniqueEntries([Path.Combine(root, "a", "x.txt"), Path.Combine(root, "b", "X.txt"),
            Path.Combine(root, "c", "x.txt"), Path.Combine(root, "d", "y")]);
        Assert.Equal(["x.txt", "X (2).txt", "x (3).txt", "y"], items.Select(i => i.EntryName));
    }

    [Theory]
    [InlineData(0x14, 1u << 20)]
    [InlineData(0xD3, (1u << 19) - 6 * (1u << 15))] // 2^19 minus 6/16
    [InlineData(0x0C, 4096u)]
    public void Lzip_dictionary_sizes(int coded, uint expected) =>
        Assert.Equal(expected, LzipReader.DictionarySize(coded));

    private static byte[] ReadAll(ZipArchiveEntry entry)
    {
        using var stream = entry.Open();
        using var ms = new MemoryStream();
        stream.CopyTo(ms);
        return ms.ToArray();
    }

    // ───────────────────────── ANSYS Workbench archives (issue #294) ─────────────────────────

    [Fact]
    public async Task A_workbench_wbpz_archive_keeps_every_entry_when_converted_to_zip()
    {
        SkipWithout7Zip();
        var input = Path.Combine(fx.NewFolder(), "project.wbpz");
        var expected = new Dictionary<string, byte[]>
        {
            ["project.wbpj"] = Encoding.UTF8.GetBytes("<?xml version=\"1.0\"?><Project name=\"Archive payload\"/>"),
            ["project_files/dp0/SYS/MECH/model.dat"] = Enumerable.Range(0, 256).Select(i => (byte)i).ToArray(),
            ["user_files/ملاحظات.txt"] = Encoding.UTF8.GetBytes("مرحبا 中文 한국어\n"),
        };
        using (var archive = ZipFile.Open(input, ZipArchiveMode.Create))
        {
            foreach (var (name, bytes) in expected)
            {
                using var entry = archive.CreateEntry(name).Open();
                entry.Write(bytes);
            }
            archive.CreateEntry("project_files/empty/");
        }

        var job = await fx.ConvertAsync([input], new Preset { TargetFormat = "zip" });

        Assert.Equal(JobState.Completed, job.State);
        using var output = ZipFile.OpenRead(Assert.Single(job.Outputs));
        Assert.Equal(expected.Keys.Order(), output.Entries.Where(e => !e.FullName.EndsWith('/')).Select(e => e.FullName).Order());
        foreach (var (name, bytes) in expected)
        {
            using var entry = output.GetEntry(name)!.Open();
            using var data = new MemoryStream();
            entry.CopyTo(data);
            Assert.Equal(bytes, data.ToArray());
        }
        Assert.NotNull(output.GetEntry("project_files/empty/"));
    }

    [Fact]
    public async Task A_wbpz_that_is_no_archive_fails()
    {
        SkipWithout7Zip();
        var input = Path.Combine(fx.NewFolder(), "invalid.wbpz");
        await File.WriteAllTextAsync(input, "This is not an archive.", TestContext.Current.CancellationToken);
        var job = await fx.ConvertAsync([input], new Preset { TargetFormat = "zip" });
        Assert.Equal(JobState.Failed, job.State);
        Assert.Empty(job.Outputs);
    }
}