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.

35.7 KB
Raw Blame
// Images and vector graphics: the extra raster formats (JPEG XL, JPEG 2000, PSD, TGA, PPM, XCF, camera RAW,
// EMF/WMF), SVG → PDF/PNG, SVGZ, ICNS, Illustrator files and Ghostscript (EPS/PS, skipped when not installed).

using System.IO.Compression;
using System.Text;
using Filee.Core.Conversion;
using Filee.Core.Presets;
using Filee.Engines.Icns;
using Filee.Engines.Magick;
using Filee.Engines.Vector;
using ImageMagick;
using PdfSharp.Pdf;
using PdfSharp.Pdf.IO;
using SkiaSharp;

namespace Filee.Engines.Tests;

public class GraphicsTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
    private static bool GhostscriptInstalled => GhostscriptConverter.Locate() is not null;

    private static void AssertDone(ConversionJob job)
    {
        var errors = string.Join("; ", job.Files.Where(f => f.State == FileState.Failed).Select(f => $"{f.ErrorKey} {f.ErrorDetail}"));
        Assert.True(job.State == JobState.Completed, $"{job.State}: {errors}");
        Assert.All(job.Outputs, o => Assert.True(new FileInfo(o).Length > 0, o));
    }

    private static IMagickColor<byte> Pixel(IMagickImage<byte> image, int x, int y) =>
        image.GetPixels().GetPixel(x, y).ToColor()!;

    private static string Write(string folder, string name, string text)
    {
        var path = Path.Combine(folder, name);
        File.WriteAllText(path, text);
        return path;
    }

    // ───────────────────────── Raster formats ─────────────────────────

    [Theory]
    [InlineData("jxl", MagickFormat.Jxl, true)]
    [InlineData("jp2", MagickFormat.Jp2, true)]
    [InlineData("psd", MagickFormat.Psd, true)]
    [InlineData("psb", MagickFormat.Psb, true)]
    [InlineData("tga", MagickFormat.Tga, true)]
    [InlineData("ppm", MagickFormat.Ppm, false)]
    public async Task Png_converts_to_the_new_raster_formats_and_back(string target, MagickFormat expected, bool keepsAlpha)
    {
        var dir = fx.NewFolder();
        var source = EngineFixture.MakeImage(dir, "a.png", MagickFormat.Png);

        var job = await fx.ConvertAsync([source], new Preset { Name = target, TargetFormat = target, Image = { Quality = 100 } });

        AssertDone(job);
        var output = job.Outputs.Single();
        Assert.Equal("." + target, Path.GetExtension(output));
        using (var result = new MagickImage(output))
        {
            Assert.Equal(expected, result.Format);
            Assert.Equal((320u, 200u), (result.Width, result.Height));
            // The transparent corner survives where the format has alpha, else it becomes the white background.
            var corner = Pixel(result, 5, 5);
            if (keepsAlpha)
                Assert.Equal(0, corner.A);
            else
                Assert.True(corner.R > 250 && corner.G > 250 && corner.B > 250, corner.ToString());
        }

        // … and back to PNG through the same engine.
        var back = await fx.ConvertAsync([output], new Preset { TargetFormat = "png", Output = { FileNamePattern = "{name}_back" } });
        AssertDone(back);
        using var png = new MagickImage(back.Outputs.Single());
        Assert.Equal((320u, 200u), (png.Width, png.Height));
    }

    [Fact]
    public async Task Jpeg_xl_quality_comes_from_the_preset_and_100_is_lossless()
    {
        var dir = fx.NewFolder();
        var source = EngineFixture.MakeImage(dir, "a.png", MagickFormat.Png, 640, 400);

        var low = await fx.ConvertAsync([source], new Preset { TargetFormat = "jxl", Image = { Quality = 40 }, Output = { FileNamePattern = "{name}_40" } });
        var high = await fx.ConvertAsync([source], new Preset { TargetFormat = "jxl", Image = { Quality = 95 }, Output = { FileNamePattern = "{name}_95" } });
        var lossless = await fx.ConvertAsync([source], new Preset { TargetFormat = "jxl", Image = { Quality = 100 }, Output = { FileNamePattern = "{name}_100" } });

        AssertDone(low);
        AssertDone(high);
        AssertDone(lossless);
        Assert.True(new FileInfo(low.Outputs.Single()).Length < new FileInfo(high.Outputs.Single()).Length);
        using var original = new MagickImage(source);
        using var exact = new MagickImage(lossless.Outputs.Single());
        Assert.Equal(0, original.Compare(exact, ErrorMetric.Absolute));
    }

    [Fact]
    public async Task Layered_psd_becomes_one_image_of_the_composite()
    {
        var dir = fx.NewFolder();
        var path = Path.Combine(dir, "layers.psd");
        using (var layers = new MagickImageCollection())
        {
            var background = new MagickImage(MagickColors.Red, 120, 80);
            var box = new MagickImage(MagickColors.Blue, 40, 30) { Page = new MagickGeometry(60, 20, 40, 30) };
            // Photoshop stores the composite first, then the layers.
            using var composite = background.Clone();
            composite.Composite(box, 60, 20, CompositeOperator.Over);
            layers.Add(composite.Clone());
            layers.Add(background);
            layers.Add(box);
            layers.Write(path, MagickFormat.Psd);
        }
        using (var check = new MagickImageCollection(path))
            Assert.True(check.Count >= 3, "the test file should contain the composite and two layers");

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

        AssertDone(job);
        using var result = new MagickImage(job.Outputs.Single());
        Assert.Equal("layers.png", Path.GetFileName(job.Outputs.Single()));
        Assert.Equal((120u, 80u), (result.Width, result.Height));
        Assert.True(Pixel(result, 10, 10).R > 200, "background layer");
        Assert.True(Pixel(result, 80, 35).B > 200 && Pixel(result, 80, 35).R < 50, "the upper layer is composited at its offset");
    }

    [Fact]
    public async Task Gimp_layers_are_flattened_at_their_offsets_and_hidden_layers_are_left_out()
    {
        var dir = fx.NewFolder();
        var path = Path.Combine(dir, "drawing.xcf");
        File.WriteAllBytes(path, GraphicsBuilders.Xcf(96, 64,
            new GraphicsBuilders.XcfLayer("Hidden", 96, 64, 0, 0, 0, 0, 255, Visible: false),
            new GraphicsBuilders.XcfLayer("Box", 16, 16, 60, 8, 0, 200, 0),
            new GraphicsBuilders.XcfLayer("Background", 48, 64, 0, 0, 220, 30, 30)));

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

        AssertDone(job);
        using var result = new MagickImage(job.Outputs.Single());
        Assert.Equal((96u, 64u), (result.Width, result.Height));
        var background = Pixel(result, 10, 10);
        Assert.True(background.R > 200 && background.B < 50, "background: " + background);
        var box = Pixel(result, 66, 12);
        Assert.True(box.G > 180 && box.R < 50 && box.B < 50, "box: " + box);
        Assert.Equal(0, Pixel(result, 80, 50).A); // outside every visible layer: transparent, not the hidden blue
    }

    [Fact]
    public async Task Netpbm_keeps_its_kind_and_grayscale_becomes_pgm()
    {
        var dir = fx.NewFolder();
        var png = EngineFixture.MakeImage(dir, "a.png", MagickFormat.Png);
        var pgm = EngineFixture.MakeImage(dir, "scan.pgm", MagickFormat.Pgm);

        var gray = await fx.ConvertAsync([png], new Preset { TargetFormat = "ppm", Image = { Grayscale = true } });
        var half = await fx.ConvertAsync([pgm], new Preset
        {
            TargetFormat = BuiltInData.SameAsSource,
            Image = { Resize = ResizeMode.Percent, ResizePercent = 50 },
            Output = { FileNamePattern = "{name}_50" },
        });

        AssertDone(gray);
        AssertDone(half);
        Assert.Equal("a.pgm", Path.GetFileName(gray.Outputs.Single()));
        Assert.Equal("scan_50.pgm", Path.GetFileName(half.Outputs.Single()));
        using var result = new MagickImage(half.Outputs.Single());
        Assert.Equal(MagickFormat.Pgm, result.Format);
        Assert.Equal(160u, result.Width);
    }

    [Theory]
    [InlineData("photo.dng")]
    [InlineData("photo.raw")] // ImageMagick alone would read ".raw" as headerless pixels
    public async Task Camera_raw_is_decoded_by_LibRaw_and_turned_upright(string name)
    {
        var dir = fx.NewFolder();
        var path = Path.Combine(dir, name);
        // Orientation 6: the camera was turned; the picture must be rotated 90° clockwise for display.
        File.WriteAllBytes(path, GraphicsBuilders.LinearDng(60, 40, orientation: 6));

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

        AssertDone(job);
        using var result = new MagickImage(job.Outputs.Single());
        Assert.Equal((40u, 60u), (result.Width, result.Height));
        // Left half red → after turning clockwise it is the top half.
        var top = Pixel(result, 20, 10);
        var bottom = Pixel(result, 20, 50);
        Assert.True(top.R > top.B + 60, "top should be red: " + top);
        Assert.True(bottom.B > bottom.R + 60, "bottom should be blue: " + bottom);
    }

    [Fact]
    public void Camera_raw_uses_the_camera_white_balance_and_srgb()
    {
        var settings = ImageReader.Settings("raw", new Preset());

        Assert.Equal(MagickFormat.Dng, settings.Format);
        Assert.Equal("true", settings.GetDefine(MagickFormat.Dng, "use-camera-wb"));
        Assert.Equal("false", settings.GetDefine(MagickFormat.Dng, "use-auto-wb"));
        Assert.Equal("1", settings.GetDefine(MagickFormat.Dng, "output-color"));
    }

    [Fact]
    public async Task Windows_metafiles_are_rendered_at_the_preset_dpi()
    {
        Assert.SkipUnless(OperatingSystem.IsWindows(), "EMF/WMF are read through GDI+ on Windows only.");
        var dir = fx.NewFolder();
        var emf = Path.Combine(dir, "chart.emf");
        var wmf = Path.Combine(dir, "clip.wmf");
        GraphicsBuilders.Emf(emf, 60, 30);
        GraphicsBuilders.Wmf(wmf, 60, 30);

        var job = await fx.ConvertAsync([emf, wmf], new Preset { TargetFormat = "png", Pdf = { RenderDpi = 200 } });
        var pdf = await fx.ConvertAsync([emf], new Preset { TargetFormat = "pdf" });

        AssertDone(job);
        AssertDone(pdf);
        foreach (var output in job.Outputs)
        {
            using var image = new MagickImage(output);
            // 60 mm at 200 dpi = 472 px (a pixel or two either way from GDI's rounding).
            Assert.InRange((int)image.Width, 460, 485);
            Assert.InRange((int)image.Height, 225, 245);
            var left = Pixel(image, (int)image.Width / 6, (int)image.Height / 2);
            var right = Pixel(image, (int)image.Width * 5 / 6, (int)image.Height / 2);
            Assert.True(left.R > 200 && left.B < 100, Path.GetFileName(output) + " left: " + left);
            Assert.True(right.G > 120 && right.R < 60, Path.GetFileName(output) + " right: " + right);
        }
        using var document = PdfReader.Open(pdf.Outputs.Single(), PdfDocumentOpenMode.Import);
        Assert.InRange(document.Pages[0].Width.Millimeter, 58, 62);
    }

    // ───────────────────────── SVG ─────────────────────────

    [Fact]
    public async Task Svg_to_pdf_is_vector()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "drawing.svg", GraphicsBuilders.Svg);

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

        AssertDone(job);
        using var document = PdfReader.Open(job.Outputs.Single(), PdfDocumentOpenMode.Import);
        Assert.Equal(1, document.PageCount);
        var page = document.Pages[0];
        // 400 × 200 CSS px = 300 × 150 pt.
        Assert.Equal(300, page.Width.Point, 1);
        Assert.Equal(150, page.Height.Point, 1);

        var content = new StringBuilder(Encoding.Latin1.GetString(page.Contents.CreateSingleContent().Stream.UnfilteredValue));
        var images = new List<(int Width, int Height)>();
        var fonts = 0;
        CollectResources(page.Resources, content, images, ref fonts, 0);
        var text = content.ToString();
        Assert.Matches(@"\s(c|l|re)\s", text); // path operators: curves, lines, rectangles
        Assert.Matches(@"\sf\*?\s", text);    // fills
        // Text is drawn as glyph outlines: Skia would embed whole font files (13 MB for one line of Korean).
        Assert.DoesNotContain("BT", text);
        Assert.Equal(0, fonts);
        Assert.True(new FileInfo(job.Outputs.Single()).Length < 100_000, "the PDF should be small");
        Assert.DoesNotContain(images, i => i.Width > 64 || i.Height > 64); // no picture of the drawing
    }

    /// <summary>Collects content of form XObjects, image sizes and font count, recursively.</summary>
    private static void CollectResources(PdfDictionary? resources, StringBuilder content, List<(int, int)> images, ref int fonts, int depth)
    {
        if (resources is null || depth > 5)
            return;
        fonts += resources.Elements.GetDictionary("/Font")?.Elements.Count ?? 0;
        var xobjects = resources.Elements.GetDictionary("/XObject");
        if (xobjects is null)
            return;
        foreach (var key in xobjects.Elements.Keys)
        {
            if (xobjects.Elements.GetDictionary(key) is { } dictionary)
            {
                var subtype = dictionary.Elements.GetName("/Subtype");
                if (subtype == "/Image")
                {
                    images.Add((dictionary.Elements.GetInteger("/Width"), dictionary.Elements.GetInteger("/Height")));
                }
                else if (subtype == "/Form")
                {
                    content.Append(Encoding.Latin1.GetString(dictionary.Stream.UnfilteredValue));
                    CollectResources(dictionary.Elements.GetDictionary("/Resources"), content, images, ref fonts, depth + 1);
                }
            }
        }
    }

    [Fact]
    public async Task Svg_to_png_is_rendered_large_enough_and_keeps_transparency()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "drawing.svg", GraphicsBuilders.Svg);

        var job = await fx.ConvertAsync([svg], new Preset { TargetFormat = "png" });
        var sized = await fx.ConvertAsync([svg], new Preset
        {
            TargetFormat = "webp",
            Image = { Resize = ResizeMode.LongEdge, LongEdge = 300, WebpLossless = true },
        });
        var jpg = await fx.ConvertAsync([svg], new Preset { TargetFormat = "jpg" });

        AssertDone(job);
        AssertDone(sized);
        AssertDone(jpg);
        using (var png = new MagickImage(job.Outputs.Single()))
        {
            // At least 1024 px on the long edge (the default 150 dpi would give only 625 px).
            Assert.Equal((1024u, 512u), (png.Width, png.Height));
            Assert.Equal(0, Pixel(png, 3, 3).A);
            var circle = Pixel(png, 512, 256);
            Assert.True(circle.R > 240 && circle.G < 20 && circle.A == 255, circle.ToString());
        }
        using (var webp = new MagickImage(sized.Outputs.Single()))
            Assert.Equal((300u, 150u), (webp.Width, webp.Height)); // rendered at exactly that size
        using (var flat = new MagickImage(jpg.Outputs.Single()))
            Assert.True(Pixel(flat, 3, 3).R > 245, "JPG gets the preset background");
    }

    [Fact]
    public void Svg_external_resources_stay_in_the_drawings_folder()
    {
        var dir = fx.NewFolder();
        var sourceDir = Path.Combine(dir, "source");
        var outsideDir = Path.Combine(dir, "source-outside"); // shares the folder name's prefix
        Directory.CreateDirectory(Path.Combine(sourceDir, "images"));
        Directory.CreateDirectory(outsideDir);
        using (var allowed = new MagickImage(MagickColors.Lime, 20, 20))
            allowed.Write(Path.Combine(sourceDir, "allowed.png"));
        using (var nested = new MagickImage(MagickColors.Blue, 20, 20))
            nested.Write(Path.Combine(sourceDir, "images", "nested.png"));
        var secret = Path.Combine(outsideDir, "secret.png");
        using (var outside = new MagickImage(MagickColors.Red, 20, 20))
            outside.Write(secret);
        Write(outsideDir, "shapes.svg", """
            <svg xmlns="http://www.w3.org/2000/svg"><rect id="r" width="20" height="20" fill="#FF0000"/></svg>
            """);
        var svg = Write(sourceDir, "drawing.svg", $"""
            <svg xmlns="http://www.w3.org/2000/svg" width="100" height="20">
              <image href="allowed.png" width="20" height="20"/>
              <image href="images/nested.png" x="20" width="20" height="20"/>
              <image href="../source-outside/secret.png" x="40" width="20" height="20"/>
              <image href="{new Uri(secret).AbsoluteUri}" x="60" width="20" height="20"/>
              <use href="../source-outside/shapes.svg#r" x="80"/>
            </svg>
            """);

        using var drawing = SvgRenderer.Load(svg);
        using var rendered = SvgRenderer.Rasterize(drawing, 1);

        var same = Pixel(rendered, 10, 10);
        Assert.True(same.G > 200 && same.R < 50, "image beside the drawing: " + same);
        var below = Pixel(rendered, 30, 10);
        Assert.True(below.B > 200 && below.R < 50, "image in a subfolder: " + below);
        foreach (var x in new[] { 50, 70, 90 })
        {
            var blocked = Pixel(rendered, x, 10);
            Assert.False(blocked.R > 200 && blocked.G < 50 && blocked.B < 50, $"resource outside the folder was drawn at x={x}: " + blocked);
        }
    }

    [Fact]
    public async Task Svg_with_a_loose_ampersand_and_html_entities_still_converts()
    {
        // Issue #120: generated SVGs with "A & B" in a <text> stopped the XML parser ("parsing EntityName").
        var dir = fx.NewFolder();
        var svg = Write(dir, "gemini.svg", """
            <svg xmlns="http://www.w3.org/2000/svg" width="200" height="100">
              <rect width="200" height="100" fill="#ff0000"/>
              <text x="10" y="50" font-size="20">Q&A &amp; R&nbsp;D &copy; 2026 &bogus;</text>
            </svg>
            """);

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

        AssertDone(job);
        using var png = new MagickImage(job.Outputs.Single());
        Assert.True(Pixel(png, 3, 3).R > 240, "the drawing was rendered");
    }

    [Theory]
    [InlineData("<t>A & B</t>", "<t>A &amp; B</t>")]
    [InlineData("<t>R&nbsp;D &copy;</t>", "<t>R&#160;D &#169;</t>")]
    [InlineData("<t>&bogus; &copy</t>", "<t>&amp;bogus; &amp;copy</t>")]
    [InlineData("<a href=\"x?a=1&b=2\"/>", "<a href=\"x?a=1&amp;b=2\"/>")]
    public void Loose_ampersands_are_escaped_and_html_entities_become_references(string svg, string repaired) =>
        Assert.Equal(repaired, Encoding.UTF8.GetString(SvgXmlRepair.FixAmpersands(Encoding.UTF8.GetBytes(svg))!));

    [Theory]
    [InlineData("<t>A &amp; B &lt; &#38; &#x26;</t>")]
    [InlineData("<!DOCTYPE svg [<!ENTITY ns_svg \"http://www.w3.org/2000/svg\">]><svg xmlns=\"&ns_svg;\"/>")]
    [InlineData("<t><!-- a & b --><![CDATA[x && y]]></t>")]
    [InlineData("<t>no ampersand</t>")]
    public void Valid_xml_is_left_as_it_is(string svg) =>
        Assert.Null(SvgXmlRepair.FixAmpersands(Encoding.UTF8.GetBytes(svg)));

    [Fact]
    public void Text_in_another_encoding_is_not_touched() =>
        Assert.Null(SvgXmlRepair.FixAmpersands(Encoding.Latin1.GetBytes("<t encoding=\"latin1\">café & co</t>")));

    [Fact]
    public async Task Svgz_round_trip()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "logo.svg", GraphicsBuilders.Svg);

        var packed = await fx.ConvertAsync([svg], new Preset { TargetFormat = "svgz" });
        AssertDone(packed);
        var svgz = packed.Outputs.Single();
        Assert.Equal([0x1F, 0x8B], File.ReadAllBytes(svgz)[..2]);

        var unpacked = await fx.ConvertAsync([svgz], new Preset { TargetFormat = "svg", Output = { FileNamePattern = "{name}_plain" } });
        var rendered = await fx.ConvertAsync([svgz], new Preset { TargetFormat = "png", Image = { Resize = ResizeMode.LongEdge, LongEdge = 200 } });

        AssertDone(unpacked);
        AssertDone(rendered);
        Assert.Equal(File.ReadAllBytes(svg), File.ReadAllBytes(unpacked.Outputs.Single()));
        using var png = new MagickImage(rendered.Outputs.Single());
        Assert.Equal(200u, png.Width);
    }

    [Fact]
    public async Task Custom_resize_stretches_a_vector_picture()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "logo.svg", GraphicsBuilders.Svg);

        var rendered = await fx.ConvertAsync([svg], new Preset
        {
            TargetFormat = "png",
            Image = { CustomSize = new() { Width = 777, Height = 333 } },
        });

        AssertDone(rendered);
        using var png = new MagickImage(rendered.Outputs.Single());
        Assert.Equal((777u, 333u), (png.Width, png.Height));
    }

    [Fact]
    public async Task Custom_resize_with_the_lock_renders_a_vector_picture_at_the_asked_size()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "logo.svg", GraphicsBuilders.Svg);

        var rendered = await fx.ConvertAsync([svg], new Preset
        {
            TargetFormat = "png",
            Image = { CustomSize = new() { Width = 777, Height = 333, LockAspect = true } },
        });

        AssertDone(rendered);
        using var png = new MagickImage(rendered.Outputs.Single());
        // The 400 x 200 drawing is rendered at min(777/400, 333/200) = 1.665: the largest 2:1 shape inside the box.
        Assert.Equal((666u, 333u), (png.Width, png.Height));
    }

    [Fact]
    public void Custom_resize_renders_vectors_at_the_asked_scale_instead_of_stretching_a_default_raster()
    {
        var image = new ImageOptions { CustomSize = new() { Width = 777, Height = 333, LockAspect = true } };
        // With the lock, the fit-inside scale: the raster already keeps the file's shape at the box's edge.
        Assert.Equal(1.665f, SvgRenderer.RasterScale(new SKRect(0, 0, 400, 200), image, new PdfOptions()), 3);

        // Without, the larger side's scale, so the stretch that follows only ever shrinks the other side.
        image.CustomSize = new() { Width = 777, Height = 333 };
        Assert.Equal(1.9425f, SvgRenderer.RasterScale(new SKRect(0, 0, 400, 200), image, new PdfOptions()), 3);

        // A size of 0 or below from a hand-edited file is no size: the raster keeps the default DPI scale.
        var zeroed = new ImageOptions { CustomSize = new() { Width = 0, Height = 333 } };
        var bounds = new SKRect(0, 0, 400, 200);
        Assert.Equal(SvgRenderer.RasterScale(bounds, new ImageOptions(), new PdfOptions()),
            SvgRenderer.RasterScale(bounds, zeroed, new PdfOptions()));
    }

    [Fact]
    public async Task Min_short_edge_renders_a_vector_picture_at_least_that_large()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "logo.svg", GraphicsBuilders.Svg);

        var rendered = await fx.ConvertAsync([svg], new Preset { TargetFormat = "png", Image = { MinShortEdge = 1080 } });

        AssertDone(rendered);
        using var png = new MagickImage(rendered.Outputs.Single());
        // The 400 x 200 drawing is drawn at 1080 / 200 = 5.4, not enlarged as a bitmap afterwards.
        Assert.Equal((2160u, 1080u), (png.Width, png.Height));
    }

    [Fact]
    public void Min_short_edge_renders_vectors_larger_only_where_the_usual_size_falls_short()
    {
        var bounds = new SKRect(0, 0, 400, 200);
        var usual = SvgRenderer.RasterScale(bounds, new ImageOptions(), new PdfOptions());

        Assert.Equal(5.4f, SvgRenderer.RasterScale(bounds, new ImageOptions { MinShortEdge = 1080 }, new PdfOptions()), 3);
        // The usual render (1024 x 512 px here) already has a short edge of 300 or more: left at that size.
        Assert.Equal(usual, SvgRenderer.RasterScale(bounds, new ImageOptions { MinShortEdge = 300 }, new PdfOptions()));
        // A minimum of 0 or below from a hand-edited file is no minimum.
        Assert.Equal(usual, SvgRenderer.RasterScale(bounds, new ImageOptions { MinShortEdge = 0 }, new PdfOptions()));
    }

    [Fact]
    public async Task Files_that_are_not_svg_fail_with_a_message()
    {
        var dir = fx.NewFolder();
        var fake = Write(dir, "fake.svg", "just text, no drawing");

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

        Assert.Equal(FileState.Failed, job.Files.Single().State);
        Assert.Contains("not an SVG", job.Files.Single().ErrorDetail);
    }

    // ───────────────────────── ICNS ─────────────────────────

    [Fact]
    public async Task Icns_holds_every_size_as_a_padded_square()
    {
        var dir = fx.NewFolder();
        var source = EngineFixture.MakeImage(dir, "app.png", MagickFormat.Png, 300, 200);

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

        AssertDone(job);
        var entries = IcnsFile.Parse(File.ReadAllBytes(job.Outputs.Single()));
        Assert.Equal(["TOC ", "icp4", "ic11", "icp5", "ic12", "ic07", "ic13", "ic08", "ic14", "ic09", "ic10"], entries.Select(e => e.Type));
        foreach (var (type, size) in IcnsFile.WrittenTypes)
        {
            using var icon = new MagickImage(entries.Single(e => e.Type == type).Data);
            Assert.Equal(MagickFormat.Png, icon.Format);
            Assert.Equal(((uint)size, (uint)size), (icon.Width, icon.Height));
        }
        using var large = new MagickImage(entries.Single(e => e.Type == "ic10").Data);
        Assert.Equal(0, Pixel(large, 512, 20).A);    // padding above the landscape picture
        Assert.Equal(255, Pixel(large, 512, 512).A); // the picture itself
    }

    [Fact]
    public async Task Icns_converts_back_from_its_largest_image()
    {
        var dir = fx.NewFolder();
        var source = EngineFixture.MakeImage(dir, "app.png", MagickFormat.Png, 256, 256);
        var icns = (await fx.ConvertAsync([source], new Preset { TargetFormat = "icns" })).Outputs.Single();

        var png = await fx.ConvertAsync([icns], new Preset { TargetFormat = "png", Output = { FileNamePattern = "{name}_icon" } });
        var jpg = await fx.ConvertAsync([icns], new Preset { TargetFormat = "jpg", Image = { Resize = ResizeMode.LongEdge, LongEdge = 100 } });

        AssertDone(png);
        AssertDone(jpg);
        using (var image = new MagickImage(png.Outputs.Single()))
            Assert.Equal((1024u, 1024u), (image.Width, image.Height));
        using (var image = new MagickImage(jpg.Outputs.Single()))
            Assert.Equal((100u, 100u), (image.Width, image.Height));
    }

    [Fact]
    public async Task Legacy_and_jpeg_2000_icns_entries_are_read()
    {
        var dir = fx.NewFolder();
        var mask = new byte[128 * 128];
        mask.AsSpan(0, 64 * 128).Fill(255); // top half opaque, bottom half transparent
        var legacy = Path.Combine(dir, "legacy.icns");
        File.WriteAllBytes(legacy, GraphicsBuilders.Icns(
            ("is32", GraphicsBuilders.LegacyRgb(16, 200, 0, 0)),
            ("s8mk", Enumerable.Repeat((byte)255, 256).ToArray()),
            ("it32", GraphicsBuilders.LegacyRgb(128, 0, 180, 40, it32: true)),
            ("t8mk", mask)));

        using var jp2Source = new MagickImage(MagickColors.Navy, 256, 256);
        var jpeg2000 = Path.Combine(dir, "jp2.icns");
        File.WriteAllBytes(jpeg2000, GraphicsBuilders.Icns(
            ("il32", GraphicsBuilders.LegacyRgb(32, 0, 0, 200)),
            ("ic08", jp2Source.ToByteArray(MagickFormat.Jp2))));

        var job = await fx.ConvertAsync([legacy, jpeg2000], new Preset { TargetFormat = "png" });

        AssertDone(job);
        using (var image = new MagickImage(job.Outputs.Single(o => Path.GetFileName(o) == "legacy.png")))
        {
            Assert.Equal((128u, 128u), (image.Width, image.Height)); // it32 is larger than is32
            var top = Pixel(image, 64, 32);
            Assert.True(top.G > 170 && top.R < 10 && top.A == 255, top.ToString());
            Assert.Equal(0, Pixel(image, 64, 100).A);
        }
        using (var image = new MagickImage(job.Outputs.Single(o => Path.GetFileName(o) == "jp2.png")))
        {
            Assert.Equal((256u, 256u), (image.Width, image.Height));
            Assert.True(Pixel(image, 10, 10).B > 100);
        }
    }

    [Fact]
    public void Icns_rle_decodes_literal_and_repeat_runs()
    {
        byte[] data = [.. Enumerable.Range(0, 300).Select(i => (byte)(i < 100 ? i : 7))];

        var decoded = IcnsFile.UnpackBits(GraphicsBuilders.PackBits(data), data.Length);

        Assert.Equal(data, decoded);
    }

    // ───────────────────────── Illustrator ─────────────────────────

    [Fact]
    public async Task Pdf_compatible_illustrator_files_convert_through_pdf()
    {
        var dir = fx.NewFolder();
        var svg = Write(dir, "art.svg", GraphicsBuilders.Svg);
        var pdf = (await fx.ConvertAsync([svg], new Preset { TargetFormat = "pdf" })).Outputs.Single();
        var ai = Path.Combine(dir, "artwork.ai");
        File.Copy(pdf, ai);

        var toPdf = await fx.ConvertAsync([ai], new Preset { TargetFormat = "pdf" });
        var toPng = await fx.ConvertAsync([ai], new Preset { TargetFormat = "png", Pdf = { RenderDpi = 96 } });

        AssertDone(toPdf);
        AssertDone(toPng);
        Assert.Equal(File.ReadAllBytes(ai), File.ReadAllBytes(toPdf.Outputs.Single()));
        using var png = new MagickImage(toPng.Outputs.Single());
        Assert.Equal((400u, 200u), (png.Width, png.Height));
    }

    [Fact]
    public async Task PostScript_illustrator_files_need_ghostscript()
    {
        var dir = fx.NewFolder();
        var ai = Write(dir, "old.ai", GraphicsBuilders.Eps);
        var garbage = Write(dir, "garbage.ai", "not an illustrator file");

        var job = await fx.ConvertAsync([ai, garbage], new Preset { TargetFormat = "pdf" });

        var old = job.Files.Single(f => f.SourcePath == ai);
        if (GhostscriptInstalled)
        {
            Assert.Equal(FileState.Done, old.State);
        }
        else
        {
            Assert.Equal(FileState.Failed, old.State);
            Assert.Contains("Ghostscript", old.ErrorDetail);
        }
        var bad = job.Files.Single(f => f.SourcePath == garbage);
        Assert.Equal(FileState.Failed, bad.State);
        Assert.Contains("not an Adobe Illustrator", bad.ErrorDetail);
    }

    // ───────────────────────── Ghostscript ─────────────────────────

    [Fact]
    public async Task Eps_converts_to_pdf_cropped_and_to_png()
    {
        Assert.SkipUnless(GhostscriptInstalled, "Ghostscript is not installed (pwsh build/fetch-engines.ps1 -Only ghostscript).");
        var dir = Path.Combine(fx.NewFolder(), "한글 폴더");
        Directory.CreateDirectory(dir);
        var eps = Write(dir, "그림 1.eps", GraphicsBuilders.Eps);

        var pdf = await fx.ConvertAsync([eps], new Preset { TargetFormat = "pdf" });
        var png = await fx.ConvertAsync([eps], new Preset { TargetFormat = "png", Pdf = { RenderDpi = 144 } });

        AssertDone(pdf);
        AssertDone(png);
        using (var document = PdfReader.Open(pdf.Outputs.Single(), PdfDocumentOpenMode.Import))
        {
            Assert.Equal(200, document.Pages[0].Width.Point, 1);
            Assert.Equal(100, document.Pages[0].Height.Point, 1);
        }
        using var image = new MagickImage(png.Outputs.Single());
        Assert.Equal((400u, 200u), (image.Width, image.Height));
        var triangle = Pixel(image, 360, 170);
        Assert.True(triangle.B > 150 && triangle.R < 100, triangle.ToString());
        // Where the drawing leaves the page empty, the PNG stays transparent (#39), not white.
        Assert.True(image.HasAlpha);
        Assert.Equal(0, Pixel(image, 2, 2).A);
    }

    [Fact]
    public async Task Pdf_converts_to_eps_per_page_and_to_postscript()
    {
        Assert.SkipUnless(GhostscriptInstalled, "Ghostscript is not installed (pwsh build/fetch-engines.ps1 -Only ghostscript).");
        var dir = fx.NewFolder();
        var pdf = (await fx.ConvertAsync([EngineFixture.MakeMultiPageTiff(dir, 3)], new Preset { TargetFormat = "pdf" })).Outputs.Single();

        var eps = await fx.ConvertAsync([pdf], new Preset { TargetFormat = "eps", Pdf = { PageRange = "2-3" } });
        var ps = await fx.ConvertAsync([pdf], new Preset { TargetFormat = "ps" });

        AssertDone(eps);
        AssertDone(ps);
        Assert.Equal(["pages_p2.eps", "pages_p3.eps"], eps.Outputs.Select(Path.GetFileName).Order(StringComparer.Ordinal));
        Assert.All(eps.Outputs, o => Assert.StartsWith("%!PS-Adobe-3.0 EPSF-3.0", File.ReadAllText(o)));
        var postScript = File.ReadAllText(ps.Outputs.Single());
        Assert.StartsWith("%!PS-Adobe-3.0", postScript);
        Assert.Equal(3, postScript.Split("%%Page:").Length - 1);
    }

    [Fact]
    public async Task Svg_converts_to_eps_through_pdf()
    {
        Assert.SkipUnless(GhostscriptInstalled, "Ghostscript is not installed (pwsh build/fetch-engines.ps1 -Only ghostscript).");
        var dir = fx.NewFolder();
        var svg = Write(dir, "logo.svg", GraphicsBuilders.Svg);

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

        AssertDone(job);
        var eps = File.ReadAllText(job.Outputs.Single());
        Assert.StartsWith("%!PS-Adobe-3.0 EPSF-3.0", eps);
        // eps2write crops to the drawn content, which lies inside the 300 × 150 pt page.
        var box = System.Text.RegularExpressions.Regex.Match(eps, @"%%BoundingBox: (\d+) (\d+) (\d+) (\d+)");
        Assert.True(box.Success, "no bounding box");
        var (left, bottom, right, top) = (int.Parse(box.Groups[1].Value), int.Parse(box.Groups[2].Value), int.Parse(box.Groups[3].Value), int.Parse(box.Groups[4].Value));
        Assert.InRange(left, 0, 30);
        Assert.InRange(bottom, 0, 40);
        Assert.InRange(right, 250, 300);
        Assert.InRange(top, 120, 150);
    }

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

    [Theory]
    [InlineData("svg", "png", "vector")]
    [InlineData("svg", "pdf", "vector")]
    [InlineData("ai", "png", "vector,pdfium")]
    [InlineData("eps", "png", "ghostscript")] // straight to PNG: keeps transparency (#39)
    [InlineData("svg", "eps", "vector,ghostscript")]
    [InlineData("raw", "jpg", "magick")]
    [InlineData("xcf", "psd", "magick")]
    [InlineData("png", "icns", "icns")]
    [InlineData("icns", "webp", "icns")]
    [InlineData("pdf", "icns", "pdfium,icns")]
    [InlineData("psd", "pdf", "pdfsharp")]
    public void Graphics_routes_use_the_expected_engines(string from, string to, string engines)
    {
        var route = fx.Catalog.CreatePlanner(["ghostscript"]).Plan(from, to);

        Assert.NotNull(route);
        Assert.Equal(engines, string.Join(',', route.Steps.Select(s => s.Converter.Id)));
    }

    [Fact]
    public void Illustrator_headers_are_recognised()
    {
        var dir = fx.NewFolder();
        var pdf = Path.Combine(dir, "a.ai");
        File.WriteAllBytes(pdf, [.. "%PDF-1.6\n"u8]);
        var ps = Write(dir, "b.ai", "%!PS-Adobe-3.0\n");
        var dos = Path.Combine(dir, "c.ai");
        File.WriteAllBytes(dos, [0xC5, 0xD0, 0xD3, 0xC6, 0, 0, 0, 0]);

        Assert.Equal(VectorConverter.AiKind.Pdf, VectorConverter.IllustratorKind(pdf));
        Assert.Equal(VectorConverter.AiKind.PostScript, VectorConverter.IllustratorKind(ps));
        Assert.Equal(VectorConverter.AiKind.PostScript, VectorConverter.IllustratorKind(dos));
    }

    [Fact]
    public void Svgz_detection_uses_the_gzip_signature()
    {
        using var buffer = new MemoryStream();
        using (var gzip = new GZipStream(buffer, CompressionLevel.Fastest, leaveOpen: true))
            gzip.Write("<svg/>"u8);

        Assert.True(SvgRenderer.IsGzip(buffer.ToArray()));
        Assert.False(SvgRenderer.IsGzip("<svg/>"u8));
    }
}