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.

86.1 KB
Raw Blame
using System.Text.Json;
using Filee.Core.Presets;
using Filee.Core.Profiles;
using Filee.Core.Settings;

namespace Filee.Core.Tests;

public class UserDataStoreTests
{
    [Theory]
    [InlineData(30)]
    [InlineData(31)]
    public void Previous_versions_learn_reported_extensions_without_taking_custom_claims(int schema)
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Settings.SchemaVersion = schema;
        if (schema == 30)
        {
            store.Presets.RemoveAll(p => p.Id is "live-photo-iphone" or "motion-photo-android");
            store.Profiles.Single(p => p.Id == "video").BackPresetIds!
                .RemoveAll(id => id is "live-photo-iphone" or "motion-photo-android");
        }
        foreach (var profile in store.Profiles)
            profile.Extensions.RemoveAll(e => e is "log" or "py" or "pac" or "bat" or "command" or "dat" or "wbpz");
        store.Profiles.Insert(0, new ToolbarProfile { Id = "my-python", Name = "My code", Extensions = ["py"] });
        store.SaveLibrary();
        store.SaveSettings();

        var upgraded = new UserDataStore(dir.Path);
        upgraded.Load();
        var text = upgraded.Profiles.Single(p => p.Id == "text");
        Assert.Contains("log", text.Extensions);
        Assert.Contains("pac", text.Extensions);
        Assert.Contains("bat", text.Extensions);
        Assert.Contains("command", text.Extensions);
        Assert.DoesNotContain("py", text.Extensions);
        Assert.Contains("py", upgraded.Profiles.Single(p => p.Id == "my-python").Extensions);
        Assert.Contains("dat", upgraded.Profiles.Single(p => p.Id == "video").Extensions);
        Assert.Contains("wbpz", upgraded.Profiles.Single(p => p.Id == "archives").Extensions);
        Assert.Equal(AppSettings.CurrentSchemaVersion, upgraded.Settings.SchemaVersion);
        Assert.Equal(LivePhotoKind.Apple, upgraded.FindPreset("live-photo-iphone")!.Media.LivePhoto);
        Assert.Equal(LivePhotoKind.Android, upgraded.FindPreset("motion-photo-android")!.Media.LivePhoto);

        // After upgrading, deliberately removing an extension must survive another load.
        text.Extensions.Remove("log");
        upgraded.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Single(reloaded.Profiles, p => p.Extensions.Contains("py"));
        Assert.Single(reloaded.Profiles, p => p.Extensions.Contains("dat"));
        Assert.DoesNotContain("log", reloaded.Profiles.Single(p => p.Id == "text").Extensions);
    }

    [Fact]
    public void A_preset_with_custom_sizing_never_writes_a_resize_name_an_older_version_rejects()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        var preset = store.Presets[0];
        preset.Image.Resize = ResizeMode.None;
        preset.Image.CustomSize = new CustomImageSize { Width = 777, Height = 333, LockAspect = true };
        store.SaveLibrary();

        // What a version without custom sizing reads: every resize stays a name it knows (so presets.json is not
        // dropped as broken and overwritten with the built-in presets) and the unknown customSize is simply skipped.
        var stored = JsonDocument.Parse(File.ReadAllText(Path.Combine(dir.Path, "presets.json")));
        foreach (var p in stored.RootElement.EnumerateArray())
        {
            var name = p.GetProperty("image").GetProperty("resize").GetString();
            Assert.Contains(name, new[] { "None", "Percent", "LongEdge", "Width" });
        }
        var image = stored.RootElement.EnumerateArray().Single(p => p.GetProperty("id").GetString() == preset.Id).GetProperty("image");
        var size = image.GetProperty("customSize");
        Assert.Equal(777, size.GetProperty("width").GetInt32());
        Assert.Equal(333, size.GetProperty("height").GetInt32());
        Assert.True(size.GetProperty("lockAspect").GetBoolean());

        // And this version reads the custom sizing back.
        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        var back = reloaded.Presets.Single(p => p.Id == preset.Id);
        Assert.Equal(ResizeMode.None, back.Image.Resize);
        Assert.Equal((777, 333, true), (back.Image.CustomSize!.Width, back.Image.CustomSize!.Height, back.Image.CustomSize!.LockAspect));
    }

    [Fact]
    public void A_resize_mode_of_Custom_is_never_written_to_presets_json()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets[0].Image.Resize = ResizeMode.Custom;
        store.SaveLibrary();

        // However custom sizing reaches the model, the file keeps a resize name every version knows.
        var stored = JsonDocument.Parse(File.ReadAllText(Path.Combine(dir.Path, "presets.json")));
        foreach (var p in stored.RootElement.EnumerateArray())
        {
            var name = p.GetProperty("image").GetProperty("resize").GetString();
            Assert.Contains(name, new[] { "None", "Percent", "LongEdge", "Width" });
        }
    }

    [Fact]
    public void A_preset_with_a_minimum_short_edge_never_writes_a_resize_name_an_older_version_rejects()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        var preset = store.Presets[0];
        preset.Image.Resize = ResizeMode.None;
        preset.Image.MinShortEdge = 1080;
        store.SaveLibrary();

        // What Filee 2.1.0 reads: every resize stays a name it knows, and the unknown minShortEdge is skipped (#652).
        var stored = JsonDocument.Parse(File.ReadAllText(Path.Combine(dir.Path, "presets.json")));
        foreach (var p in stored.RootElement.EnumerateArray())
        {
            var name = p.GetProperty("image").GetProperty("resize").GetString();
            Assert.Contains(name, new[] { "None", "Percent", "LongEdge", "Width" });
        }
        var image = stored.RootElement.EnumerateArray().Single(p => p.GetProperty("id").GetString() == preset.Id).GetProperty("image");
        Assert.Equal(1080, image.GetProperty("minShortEdge").GetInt32());
        // Presets without it keep the shape they had: no "minShortEdge": null written into each one.
        Assert.All(stored.RootElement.EnumerateArray().Where(p => p.GetProperty("id").GetString() != preset.Id),
            p => Assert.False(p.GetProperty("image").TryGetProperty("minShortEdge", out _)));

        // And this version reads it back.
        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        var back = reloaded.Presets.Single(p => p.Id == preset.Id);
        Assert.Equal(ResizeMode.None, back.Image.Resize);
        Assert.Equal(1080, back.Image.MinShortEdge);
        Assert.True(back.Image.EditsPicture);
        Assert.Equal(1080, back.Image.Clone().MinShortEdge);
    }

    [Fact]
    public void A_resize_mode_of_MinShortEdge_is_never_written_to_presets_json()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets[0].Image.Resize = ResizeMode.MinShortEdge;
        store.SaveLibrary();

        var stored = JsonDocument.Parse(File.ReadAllText(Path.Combine(dir.Path, "presets.json")));
        Assert.Equal("None", stored.RootElement[0].GetProperty("image").GetProperty("resize").GetString());
    }

    [Fact]
    public void A_resize_name_this_version_does_not_know_reads_as_no_resize()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets[0].Name = "mine";
        store.SaveLibrary();

        // A preset from a future version, or a hand-edited one: a resize name this version has never heard of.
        var path = Path.Combine(dir.Path, "presets.json");
        var original = File.ReadAllText(path);
        var edited = original.Replace("\"resize\": \"None\"", "\"resize\": \"Quantum\"");
        Assert.NotEqual(original, edited);
        File.WriteAllText(path, edited);

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(ResizeMode.None, reloaded.Presets[0].Image.Resize);   // the lenient converter, not a broken file
        Assert.Equal("mine", reloaded.Presets[0].Name);                    // and the library was kept, not replaced
    }

    [Fact]
    public void Groups_keep_only_conversions_once_and_at_most_six()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets.Add(new Preset { Id = "other", Name = "Other", Kind = PresetKind.Group, SubPresetIds = ["to-pdf"] });
        store.Presets.Add(new Preset
        {
            Id = "mine",
            Name = "Mine",
            Kind = PresetKind.Group,
            SubPresetIds = ["to-png", "gone", "to-png", "other", "to-jpg", "to-webp", "to-bmp", "to-gif", "to-ico", "to-tiff"],
        });
        store.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        // A deleted preset and a group in the group are dropped, a repeat counts once, the rest is cut at six.
        var group = reloaded.FindPreset("mine")!;
        Assert.True(group.IsGroup);
        Assert.Equal(["to-png", "to-jpg", "to-webp", "to-bmp", "to-gif", "to-ico"], group.SubPresetIds);
        // No target format a Filee from before groups (which reads it as a conversion) could run it with.
        Assert.Equal(Preset.GroupTarget, group.TargetFormat);
        Assert.Null(Filee.Core.Formats.FormatRegistry.FindById(Preset.GroupTarget));
    }

    [Fact]
    public void Only_a_conversion_is_found_to_run()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets.Add(new Preset { Id = "web", Name = "Web", Kind = PresetKind.Group, SubPresetIds = ["to-png"] });

        Assert.NotNull(store.FindPreset("web")); // to edit it
        Assert.Null(store.FindConversion("web")); // never to run it (a watch folder pointing at it converts nothing)
        Assert.Equal("to-png", store.FindConversion("to-png")!.Id);
    }

    [Fact]
    public void A_kind_from_a_newer_Filee_reads_as_a_group_and_the_other_presets_still_load()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets.Add(new Preset { Id = "future", Name = "Future", Kind = PresetKind.Group, SubPresetIds = ["to-png"] });
        store.SaveLibrary();
        var path = Path.Combine(dir.Path, "presets.json");
        var json = File.ReadAllText(path);
        Assert.Contains("\"kind\": \"Group\"", json);
        File.WriteAllText(path, json.Replace("\"kind\": \"Group\"", "\"kind\": \"Chain\""));

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        Assert.True(reloaded.FindPreset("future")!.IsGroup); // never run as a conversion
        Assert.NotNull(reloaded.FindPreset("to-png")); // and not every preset reset to the defaults
        Assert.False(File.Exists(path + ".broken"));
    }

    [Fact]
    public void A_group_saved_by_a_Filee_from_before_groups_is_still_a_group()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets.Add(new Preset { Id = "old-group", Name = "Rotate", Kind = PresetKind.Group, SubPresetIds = ["to-png"] });
        store.SaveLibrary();

        // An older Filee knows neither "kind" nor "subPresetIds" and leaves them out when it saves.
        var path = Path.Combine(dir.Path, "presets.json");
        var presets = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsArray();
        var saved = presets.Single(p => (string?)p!["id"] == "old-group")!.AsObject();
        Assert.True(saved.Remove("kind"));
        Assert.True(saved.Remove("subPresetIds"));
        File.WriteAllText(path, presets.ToJsonString());

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        var group = reloaded.FindPreset("old-group")!;
        Assert.True(group.IsGroup); // not a conversion to "group" in the preset list, watch folders and the CLI
        Assert.Empty(group.SubPresetIds);
        Assert.Null(reloaded.FindConversion("old-group"));
    }

    [Fact]
    public void Round_trips_settings_presets_and_profiles()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Settings.Language = "ko";
        store.Settings.Theme.Accent = "#1D9E75";
        store.Settings.Triggers[0].Modifiers = ModifierKeys.Alt | ModifierKeys.Shift;
        store.Presets.Add(new Preset { Id = "mine", Name = "Mine", TargetFormat = "webp", Image = { Quality = 42 } });
        store.Profiles[0].PresetIds.Insert(0, "mine");
        store.SaveSettings();
        store.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        Assert.Equal("ko", reloaded.Settings.Language);
        Assert.Equal("#1D9E75", reloaded.Settings.Theme.Accent);
        Assert.Equal(ModifierKeys.Alt | ModifierKeys.Shift, reloaded.Settings.Triggers[0].Modifiers);
        Assert.Equal(42, reloaded.FindPreset("mine")!.Image.Quality);
        Assert.Equal("mine", reloaded.Profiles[0].PresetIds[0]);
    }

    [Fact]
    public void Dock_and_menu_bar_preferences_round_trip_independently()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        Assert.True(store.Settings.ShowInDock);
        Assert.True(store.Settings.ShowMenuBarIcon);

        store.Settings.ShowInDock = false;
        store.SaveSettings();
        var dockOff = new UserDataStore(dir.Path);
        dockOff.Load();
        Assert.False(dockOff.Settings.ShowInDock);
        Assert.True(dockOff.Settings.ShowMenuBarIcon);

        dockOff.Settings.ShowInDock = true;
        dockOff.Settings.ShowMenuBarIcon = false;
        dockOff.SaveSettings();
        var menuBarOff = new UserDataStore(dir.Path);
        menuBarOff.Load();
        Assert.True(menuBarOff.Settings.ShowInDock);
        Assert.False(menuBarOff.Settings.ShowMenuBarIcon);

        menuBarOff.Settings.ShowInDock = false;
        menuBarOff.SaveSettings();
        var bothOff = new UserDataStore(dir.Path);
        bothOff.Load();
        Assert.False(bothOff.Settings.ShowInDock);
        Assert.False(bothOff.Settings.ShowMenuBarIcon);
    }

    [Fact]
    public void Version_20_settings_upgrade_preserves_other_values_and_icon_defaults()
    {
        using var dir = new TempDir();
        var path = Path.Combine(dir.Path, "settings.json");
        File.WriteAllText(path, """{ "schemaVersion": 20, "language": "ko" }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.Equal(AppSettings.CurrentSchemaVersion, store.Settings.SchemaVersion);
        Assert.Equal("ko", store.Settings.Language);
        Assert.True(store.Settings.ShowInDock);
        Assert.True(store.Settings.ShowMenuBarIcon);
        var rewritten = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsObject();
        Assert.Equal(AppSettings.CurrentSchemaVersion, (int?)rewritten["schemaVersion"]);
        Assert.True((bool?)rewritten["showInDock"]);
        Assert.True((bool?)rewritten["showMenuBarIcon"]);
        Assert.Equal("ko", (string?)rewritten["language"]);

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(AppSettings.CurrentSchemaVersion, reloaded.Settings.SchemaVersion);
        Assert.Equal("ko", reloaded.Settings.Language);
        Assert.True(reloaded.Settings.ShowInDock);
        Assert.True(reloaded.Settings.ShowMenuBarIcon);
    }

    [Fact]
    public void Older_Filee_round_trip_restores_missing_icon_defaults()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Settings.Language = "ko";
        store.Settings.ShowInDock = false;
        store.Settings.ShowMenuBarIcon = false;
        store.SaveSettings();

        var path = Path.Combine(dir.Path, "settings.json");
        var json = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsObject();
        json["schemaVersion"] = 20;
        Assert.True(json.Remove("showInDock"));
        Assert.True(json.Remove("showMenuBarIcon"));
        File.WriteAllText(path, json.ToJsonString());

        var migrated = new UserDataStore(dir.Path);
        migrated.Load();

        Assert.Equal(AppSettings.CurrentSchemaVersion, migrated.Settings.SchemaVersion);
        Assert.True(migrated.Settings.ShowInDock);
        Assert.True(migrated.Settings.ShowMenuBarIcon);
        Assert.Equal("ko", migrated.Settings.Language);
        Assert.False(File.Exists(path + ".broken"));

        var rewritten = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsObject();
        Assert.Equal(AppSettings.CurrentSchemaVersion, (int?)rewritten["schemaVersion"]);
        Assert.True((bool?)rewritten["showInDock"]);
        Assert.True((bool?)rewritten["showMenuBarIcon"]);
        Assert.Equal("ko", (string?)rewritten["language"]);

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(AppSettings.CurrentSchemaVersion, reloaded.Settings.SchemaVersion);
        Assert.Equal("ko", reloaded.Settings.Language);
        Assert.True(reloaded.Settings.ShowInDock);
        Assert.True(reloaded.Settings.ShowMenuBarIcon);
    }

    [Theory]
    [InlineData("showInDock", "null")]
    [InlineData("showInDock", "\"future\"")]
    [InlineData("showInDock", "42")]
    [InlineData("showMenuBarIcon", "null")]
    [InlineData("showMenuBarIcon", "\"future\"")]
    [InlineData("showMenuBarIcon", "42")]
    public void Unexpected_icon_preference_values_default_on_without_losing_settings(string field, string value)
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Settings.Language = "ko";
        store.Settings.ShowInDock = field == "showInDock";
        store.Settings.ShowMenuBarIcon = field == "showMenuBarIcon";
        store.SaveSettings();

        var path = Path.Combine(dir.Path, "settings.json");
        var json = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsObject();
        json[field] = System.Text.Json.Nodes.JsonNode.Parse(value);
        File.WriteAllText(path, json.ToJsonString());

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        Assert.Equal("ko", reloaded.Settings.Language);
        Assert.True(field == "showInDock" ? reloaded.Settings.ShowInDock : reloaded.Settings.ShowMenuBarIcon);
        Assert.False(field == "showInDock" ? reloaded.Settings.ShowMenuBarIcon : reloaded.Settings.ShowInDock);
        Assert.False(File.Exists(path + ".broken"));
    }

    [Fact]
    public void Hardware_encoding_is_saved_and_stays_off_for_presets_from_before_it()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        Assert.All(store.Presets, p => Assert.False(p.Media.HardwareEncoding)); // no built-in preset turns it on
        store.Presets.Add(new Preset { Id = "fast", Name = "Fast", TargetFormat = "mp4", Media = { HardwareEncoding = true, VideoCodec = VideoCodec.Hevc } });
        store.Presets.Add(new Preset { Id = "old", Name = "Old", TargetFormat = "mp4" });
        store.SaveLibrary();

        // A Filee from before the option saved no "hardwareEncoding".
        var path = Path.Combine(dir.Path, "presets.json");
        var presets = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsArray();
        Assert.True((bool)presets.Single(p => (string?)p!["id"] == "fast")!["media"]!["hardwareEncoding"]!);
        Assert.True(presets.Single(p => (string?)p!["id"] == "old")!["media"]!.AsObject().Remove("hardwareEncoding"));
        File.WriteAllText(path, presets.ToJsonString());

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        var fast = reloaded.FindPreset("fast")!;
        Assert.True(fast.Media.HardwareEncoding);
        Assert.Equal(VideoCodec.Hevc, fast.Media.VideoCodec);
        Assert.True(fast.Clone().Media.HardwareEncoding);
        Assert.False(reloaded.FindPreset("old")!.Media.HardwareEncoding);
    }

    [Fact]
    public void Animation_speed_is_saved_and_is_the_original_speed_for_presets_from_before_it()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        Assert.All(store.Presets, p => Assert.Equal(1, p.Image.AnimationSpeed)); // no built-in preset changes it
        store.Presets.Add(new Preset { Id = "slow", Name = "Slow", TargetFormat = "gif", Image = { AnimationSpeed = 0.5 } });
        store.Presets.Add(new Preset { Id = "old", Name = "Old", TargetFormat = "gif" });
        store.Presets.Add(new Preset { Id = "odd", Name = "Odd", TargetFormat = "gif" });
        store.SaveLibrary();

        // A Filee from before the option saved no "animationSpeed"; a hand-edited file may hold anything.
        var path = Path.Combine(dir.Path, "presets.json");
        var presets = System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(path))!.AsArray();
        Assert.Equal(0.5, (double)presets.Single(p => (string?)p!["id"] == "slow")!["image"]!["animationSpeed"]!);
        Assert.True(presets.Single(p => (string?)p!["id"] == "old")!["image"]!.AsObject().Remove("animationSpeed"));
        presets.Single(p => (string?)p!["id"] == "odd")!["image"]!["animationSpeed"] = -3;
        File.WriteAllText(path, presets.ToJsonString());

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        var slow = reloaded.FindPreset("slow")!;
        Assert.Equal(0.5, slow.Image.AnimationSpeed);
        Assert.Equal(0.5, slow.Clone().Image.AnimationSpeed);
        Assert.True(slow.Image.ChangesSpeed);
        Assert.Equal(1, reloaded.FindPreset("old")!.Image.AnimationSpeed);
        Assert.False(reloaded.FindPreset("old")!.Image.ChangesSpeed);
        Assert.Equal(1, reloaded.FindPreset("odd")!.Image.PlaybackSpeed); // a speed that makes no sense plays as made
    }

    [Fact]
    public void History_is_kept_until_turned_off_and_can_be_cleared()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();

        store.AddHistory(new Filee.Core.History.HistoryEntry { JobId = "a" });
        Assert.Single(store.History);

        store.Settings.KeepHistory = false;
        store.AddHistory(new Filee.Core.History.HistoryEntry { JobId = "b" });
        Assert.Single(store.History); // not recorded

        store.ClearHistory();
        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Empty(reloaded.History);
    }

    [Fact]
    public void History_keeps_the_newest_entries_up_to_the_limit()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        Assert.Equal(200, store.Settings.HistoryLimit);

        store.Settings.HistoryLimit = 60;
        for (var i = 0; i < 70; i++)
            store.AddHistory(new Filee.Core.History.HistoryEntry { JobId = $"{i}" });
        Assert.Equal(60, store.History.Count);
        Assert.Equal("69", store.History[0].JobId);
        Assert.Equal("10", store.History[^1].JobId);

        // Lowered below the smallest limit: the oldest go with the next conversion, down to that smallest limit.
        store.Settings.HistoryLimit = 0;
        store.SaveSettings();
        store.AddHistory(new Filee.Core.History.HistoryEntry { JobId = "70" });
        Assert.Equal(AppSettings.MinHistoryLimit, store.History.Count);

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(0, reloaded.Settings.HistoryLimit);
        Assert.Equal(AppSettings.MinHistoryLimit, reloaded.Settings.EffectiveHistoryLimit);
        Assert.Equal(AppSettings.MinHistoryLimit, reloaded.History.Count);
    }

    [Fact]
    public void Version_1_settings_are_upgraded_to_the_current_engine_list()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"),
            """{ "schemaVersion": 1, "enginePriority": ["magick", "word", "hancom", "libreoffice"] }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.Equal(["magick", "markdown", "spreadsheet", "ooxml", "hwpx-writer", "docx-writer", "pdf-text", "pdf-slides", "email", "data", "vector", "icns", "font", "cad", "model3d", "geo", "archive", "ebook", "subtitle", "wic", "ffmpeg", "pandoc", "ghostscript", "calibre", "libreoffice"], store.Settings.EnginePriority);
        Assert.Equal(AppSettings.CurrentSchemaVersion, store.Settings.SchemaVersion);
    }

    [Fact]
    public void Version_3_libraries_get_the_text_profile_once()
    {
        using var dir = new TempDir();
        var old = new UserDataStore(dir.Path);
        old.Load();
        old.Profiles.RemoveAll(p => p.Id == "text"); // as written by 1.0.0
        old.Settings.SchemaVersion = 3;
        old.Settings.EnginePriority.Remove("markdown");
        old.SaveSettings();
        old.SaveLibrary();

        var store = new UserDataStore(dir.Path);
        store.Load();

        var ids = store.Profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("mixed") - 1, ids.IndexOf("text")); // right before the fallback
        Assert.Contains("md", store.Profiles.Single(p => p.Id == "text").Extensions);
        Assert.Equal(store.Settings.EnginePriority.IndexOf("hwpx-writer") - 1, store.Settings.EnginePriority.IndexOf("markdown"));

        // Saved right away: the next start neither migrates again nor brings back a profile the user deleted.
        store.Profiles.RemoveAll(p => p.Id == "text");
        store.SaveLibrary();
        var next = new UserDataStore(dir.Path);
        next.Load();
        Assert.DoesNotContain(next.Profiles, p => p.Id == "text");
        Assert.Equal(AppSettings.CurrentSchemaVersion, next.Settings.SchemaVersion);
    }

    [Fact]
    public void Version_4_libraries_get_spreadsheet_and_presentation_profiles()
    {
        using var dir = new TempDir();
        var old = new UserDataStore(dir.Path);
        old.Load();
        // As written by 1.0.1: one documents donut for Word, Excel and PowerPoint files, Word-only PDF targets.
        old.Profiles.RemoveAll(p => p.Id is "spreadsheets" or "presentations");
        old.Profiles.Single(p => p.Id == "office").Extensions.AddRange(["xlsx", "xls", "ods", "csv", "pptx", "ppt", "odp"]);
        old.Profiles.Single(p => p.Id == "pdf").PresetIds.AddRange(["to-docx", "to-hwpx"]);
        old.Presets.RemoveAll(p => p.Id is "to-xlsx" or "to-csv");
        old.Settings.SchemaVersion = 4;
        old.Settings.EnginePriority = ["magick", "word", "markdown", "hwpx-writer", "pandoc", "libreoffice"];
        old.SaveSettings();
        old.SaveLibrary();

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.Equal(["magick", "markdown", "spreadsheet", "ooxml", "hwpx-writer", "docx-writer", "pdf-text", "pdf-slides", "email", "data", "vector", "icns", "font", "cad", "model3d", "geo", "archive", "ebook", "subtitle", "wic", "ffmpeg", "pandoc", "ghostscript", "calibre", "libreoffice"], store.Settings.EnginePriority);
        var ids = store.Profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("office") + 1, ids.IndexOf("spreadsheets"));
        Assert.Equal(ids.IndexOf("office") + 2, ids.IndexOf("presentations"));
        Assert.DoesNotContain("xlsx", store.Profiles.Single(p => p.Id == "office").Extensions);
        Assert.Contains("to-csv", store.Profiles.Single(p => p.Id == "spreadsheets").PresetIds);
        Assert.NotNull(store.FindPreset("to-xlsx"));
        Assert.DoesNotContain("to-hwpx", store.Profiles.Single(p => p.Id == "pdf").PresetIds); // Word-only target removed by v5
    }

    [Fact]
    public void Version_5_libraries_get_the_format_catalog()
    {
        // As written by 1.0.x with schema 5: no catalog presets, donuts or extensions.
        var presets = BuiltInData.CreatePresets()
            .Where(p => BuiltInData.CatalogPresets().Concat(BuiltInData.CodecAndSubtitlePresets()).Concat(BuiltInData.ModelPresets()).Concat(BuiltInData.GeoPresets()).All(c => c.Id != p.Id)).ToList();
        var catalogIds = BuiltInData.CatalogProfiles().Select(p => p.Id).Append("subtitles").Append("models").Append("geo").ToHashSet();
        var profiles = BuiltInData.CreateProfiles().Where(p => !catalogIds.Contains(p.Id)).ToList();
        profiles.Single(p => p.Id == "images").Extensions = ["png", "jpg"];
        profiles.Single(p => p.Id == "pdf").PresetIds.Remove("to-docx");
        profiles.Single(p => p.Id == "mixed").PresetIds.Remove("zip-all");
        // A donut of the user already handles MP3.
        profiles.Insert(0, new ToolbarProfile { Id = "mine", Name = "Mine", Extensions = ["mp3"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(5, presets, profiles));

        var ids = profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("text") + 1, ids.IndexOf("ebooks"));
        Assert.Equal(ids.IndexOf("fonts") + 1, ids.IndexOf("data")); // schema 14
        Assert.Equal(ids.IndexOf("data") + 1, ids.IndexOf("models")); // schema 15
        Assert.Equal(ids.IndexOf("models") + 1, ids.IndexOf("geo")); // schema 25
        Assert.Equal(ids.IndexOf("mixed") - 1, ids.IndexOf("geo"));
        Assert.Equal(ids.IndexOf("audio") + 1, ids.IndexOf("subtitles"));
        Assert.Contains("cr2", profiles.Single(p => p.Id == "images").Extensions);
        Assert.DoesNotContain("mp3", profiles.Single(p => p.Id == "audio").Extensions);
        Assert.Contains("flac", profiles.Single(p => p.Id == "audio").Extensions);
        Assert.Contains(presets, p => p.Id == "to-mp4");
        Assert.Equal(["to-png", "to-jpg", "to-docx"], profiles.Single(p => p.Id == "pdf").PresetIds.Take(3));
        Assert.Contains("zip-all", profiles.Single(p => p.Id == "mixed").PresetIds);
        // Every extension belongs to one donut only.
        var all = profiles.SelectMany(p => p.Extensions).ToList();
        Assert.Equal(all.Count, all.Distinct(StringComparer.OrdinalIgnoreCase).Count());
    }

    [Fact]
    public void Version_6_libraries_get_the_conversions_that_were_on_no_donut()
    {
        // As written by 1.3.0: no HWP preset, and the donuts below without the targets 1.3.1 added.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "to-hwp");
        var profiles = BuiltInData.CreateProfiles();
        foreach (var profile in profiles)
            profile.PresetIds.Remove("to-hwp");
        profiles.Single(p => p.Id == "pdf").PresetIds.RemoveAll(id => id is "to-md" or "to-epub");
        profiles.Single(p => p.Id == "office").PresetIds.Remove("to-png");
        profiles.Single(p => p.Id == "hwp").PresetIds.RemoveAll(id => id is "to-jpg" or "to-epub");

        Assert.True(SettingsMigrations.ApplyToLibrary(6, presets, profiles));

        // The same donuts as a new install.
        Assert.NotNull(presets.SingleOrDefault(p => p.Id == "to-hwp"));
        foreach (var expected in BuiltInData.CreateProfiles())
            Assert.Equal(expected.PresetIds, profiles.Single(p => p.Id == expected.Id).PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(6, presets, profiles)); // once only
    }

    [Fact]
    public void Version_8_libraries_get_the_long_image_preset_after_jpg_and_a_heic_preset()
    {
        // As written by 1.9.0: no "Long image" or HEIC preset, and the PDF donut without the long image.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id is "pdf-long-image" or "to-heic");
        var profiles = BuiltInData.CreateProfiles();
        var pdf = profiles.Single(p => p.Id == "pdf");
        pdf.PresetIds.Remove("pdf-long-image");

        Assert.True(SettingsMigrations.ApplyToLibrary(8, presets, profiles));

        var longImage = presets.Single(p => p.Id == "pdf-long-image");
        Assert.True(longImage.Pdf.CombinePages);
        Assert.Equal(pdf.PresetIds.IndexOf("to-jpg") + 1, pdf.PresetIds.IndexOf("pdf-long-image"));
        Assert.Equal("heic", presets.Single(p => p.Id == "to-heic").TargetFormat);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("to-heic"));
        Assert.False(SettingsMigrations.ApplyToLibrary(8, presets, profiles)); // once only
    }

    [Fact]
    public void Version_9_libraries_get_the_remove_background_preset_on_no_donut()
    {
        // As written by 1.10.x: no "Remove background" preset.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "remove-background");
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(9, presets, profiles));

        var preset = presets.Single(p => p.Id == "remove-background");
        Assert.True(preset.Image.RemoveBackground);
        Assert.Equal("png", preset.TargetFormat);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("remove-background"));
        Assert.False(SettingsMigrations.ApplyToLibrary(9, presets, profiles)); // once only
    }

    [Fact]
    public void Version_18_libraries_get_the_extract_frames_presets_after_the_pdf_presets_on_no_donut()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id is "extract-frames-png" or "extract-frames-jpg");
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(18, presets, profiles));

        var pngPreset = presets.Single(p => p.Id == "extract-frames-png");
        Assert.True(pngPreset.Media.SaveEveryFrame);
        Assert.Equal("png", pngPreset.TargetFormat);

        var jpgPreset = presets.Single(p => p.Id == "extract-frames-jpg");
        Assert.True(jpgPreset.Media.SaveEveryFrame);
        Assert.Equal("jpg", jpgPreset.TargetFormat);

        // Where a new library has them.
        Assert.Equal(BuiltInData.CreatePresets().Select(p => p.Id), presets.Select(p => p.Id));
        var slides = presets.FindIndex(p => p.Id == "pdf-slides");
        Assert.Equal(["extract-frames-png", "extract-frames-jpg"], presets.Skip(slides + 1).Take(2).Select(p => p.Id));

        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("extract-frames-png"));
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("extract-frames-jpg"));
        Assert.False(SettingsMigrations.ApplyToLibrary(18, presets, profiles)); // once only
    }

    [Fact]
    public void Version_13_libraries_get_the_data_donut_msg_files_and_json_for_spreadsheets()
    {
        // As written with schema 13: no data presets or donut, no MSG on the documents donut, no JSON on the spreadsheets
        // donut; and a donut of the user that already takes YAML.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => BuiltInData.DataPresets().Any(d => d.Id == p.Id));
        var profiles = BuiltInData.CreateProfiles();
        profiles.RemoveAll(p => p.Id == "data");
        profiles.Single(p => p.Id == "office").Extensions.Remove("msg");
        profiles.Single(p => p.Id == "spreadsheets").PresetIds.Remove("to-json");
        profiles.Insert(0, new ToolbarProfile { Id = "mine", Name = "Mine", Extensions = ["yml"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(13, presets, profiles));

        Assert.All(BuiltInData.DataPresets(), d => Assert.Contains(presets, p => p.Id == d.Id));
        var ids = profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("fonts") + 1, ids.IndexOf("data"));
        var data = profiles.Single(p => p.Id == "data");
        Assert.Contains("json", data.Extensions);
        Assert.Contains("yaml", data.Extensions);
        Assert.DoesNotContain("yml", data.Extensions); // the user's donut keeps it
        Assert.Equal(["to-json", "to-yaml", "to-toml", "to-xml", "to-csv", "to-xlsx"], data.PresetIds);
        Assert.Contains("msg", profiles.Single(p => p.Id == "office").Extensions);
        var sheets = profiles.Single(p => p.Id == "spreadsheets").PresetIds;
        Assert.Equal(sheets.IndexOf("to-csv") + 1, sheets.IndexOf("to-json"));
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("to-eml") || p.PresetIds.Contains("to-vcf"));
        Assert.False(SettingsMigrations.ApplyToLibrary(13, presets, profiles)); // once only

        var all = profiles.SelectMany(p => p.Extensions).ToList();
        Assert.Equal(all.Count, all.Distinct(StringComparer.OrdinalIgnoreCase).Count());
    }

    [Fact]
    public void Version_13_settings_get_the_data_engine_after_email()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"),
            """{ "schemaVersion": 13, "enginePriority": ["magick", "email", "vector", "pandoc", "libreoffice"] }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        // ... and, from schema 15, the 3D model engine before Pandoc (no CAD or archive engine in this list), from
        // schema 18 the PDF slides engine there too (no PDF text engine), from schema 21 the WIC engine (no FFmpeg),
        // from schema 25 the geospatial engine after the 3D models engine.
        Assert.Equal(["magick", "email", "data", "vector", "model3d", "geo", "pdf-slides", "wic", "pandoc", "libreoffice"], store.Settings.EnginePriority);
    }

    [Fact]
    public void Version_12_libraries_open_the_new_image_formats_on_the_images_donut()
    {
        // As written with schema 12: the images donut knows no APNG, QOI, DICOM or .hif; a donut of the user takes DDS.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var images = profiles.Single(p => p.Id == "images");
        images.Extensions.RemoveAll(e => e is "apng" or "qoi" or "dcm" or "hif" or "dds");
        profiles.Insert(0, new ToolbarProfile { Id = "game", Name = "Game textures", Extensions = ["dds"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(12, presets, profiles));

        Assert.Contains("apng", images.Extensions);
        Assert.Contains("qoi", images.Extensions);
        Assert.Contains("dcm", images.Extensions);
        Assert.Contains("hif", images.Extensions);
        Assert.DoesNotContain("dds", images.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(12, presets, profiles)); // once only
    }

    [Fact]
    public void Version_11_libraries_get_codecs_new_audio_formats_and_a_subtitles_donut()
    {
        // As written with schema 11: no HEVC / AV1 / ALAC / subtitle presets, no subtitles donut, the video donut and
        // the audio extensions of that time, and a donut of the user that already takes .ape.
        var added = BuiltInData.CodecAndSubtitlePresets().Select(p => p.Id).ToHashSet();
        var presets = BuiltInData.CreatePresets().Where(p => !added.Contains(p.Id)).ToList();
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id != "subtitles").ToList();
        foreach (var profile in profiles)
            profile.PresetIds.RemoveAll(added.Contains);
        var audio = profiles.Single(p => p.Id == "audio");
        audio.Extensions.RemoveAll(e => e is "wv" or "tta" or "w64" or "eac3" or "ec3" or "ape" or "mpc" or "mpp" or "mp+" or "tak"
            or "dsf" or "dff" or "dts" or "spx");
        profiles.Insert(0, new ToolbarProfile { Id = "mine", Name = "Mine", Extensions = ["ape"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(11, presets, profiles));

        Assert.Contains("wv", audio.Extensions);
        Assert.Contains("dsf", audio.Extensions);
        Assert.DoesNotContain("ape", audio.Extensions); // the user's donut keeps it
        var ids = profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("audio") + 1, ids.IndexOf("subtitles"));
        Assert.Equal(BuiltInData.SubtitleProfile().PresetIds, profiles.Single(p => p.Id == "subtitles").PresetIds);
        Assert.Contains("smi", profiles.Single(p => p.Id == "subtitles").Extensions);
        Assert.Equal(BuiltInData.CreateProfiles().Single(p => p.Id == "video").PresetIds, profiles.Single(p => p.Id == "video").PresetIds);
        Assert.Equal(VideoCodec.Hevc, presets.Single(p => p.Id == "mp4-hevc").Media.VideoCodec);
        Assert.Equal(AudioCodec.Alac, presets.Single(p => p.Id == "to-alac").Media.AudioCodec);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("to-alac") || p.PresetIds.Contains("mp4-av1"));
        var all = profiles.SelectMany(p => p.Extensions).ToList();
        Assert.Equal(all.Count, all.Distinct(StringComparer.OrdinalIgnoreCase).Count());
        Assert.False(SettingsMigrations.ApplyToLibrary(11, presets, profiles)); // once only
    }

    [Fact]
    public void Version_10_libraries_get_kepub_and_the_new_document_extensions()
    {
        // As written by 1.11.x: no KEPUB preset, and the donuts without the formats added in schema 11.
        string[] added = ["org", "adoc", "typ", "mediawiki", "wiki", "dbk", "ipynb", "fodt", "ott", "cwk", "602", "ots", "fods", "otp", "fodp", "fodg", "kepub.epub"];
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "to-kepub");
        var profiles = BuiltInData.CreateProfiles();
        foreach (var profile in profiles)
        {
            profile.PresetIds.Remove("to-kepub");
            profile.Extensions.RemoveAll(added.Contains);
        }
        // A donut of the user already handles Org files.
        profiles.Insert(0, new ToolbarProfile { Id = "mine", Name = "Mine", Extensions = ["org"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(10, presets, profiles));

        Assert.Equal("kepub", presets.Single(p => p.Id == "to-kepub").TargetFormat);
        var ebooks = profiles.Single(p => p.Id == "ebooks");
        Assert.Equal(ebooks.PresetIds.IndexOf("to-mobi") + 1, ebooks.PresetIds.IndexOf("to-kepub"));
        Assert.Contains("kepub.epub", ebooks.Extensions);
        Assert.Contains("typ", profiles.Single(p => p.Id == "text").Extensions);
        Assert.DoesNotContain("org", profiles.Single(p => p.Id == "text").Extensions);
        Assert.Contains("fodt", profiles.Single(p => p.Id == "office").Extensions);
        Assert.Contains("fods", profiles.Single(p => p.Id == "spreadsheets").Extensions);
        Assert.Contains("otp", profiles.Single(p => p.Id == "presentations").Extensions);
        Assert.Contains("fodg", profiles.Single(p => p.Id == "vector").Extensions);
        foreach (var expected in BuiltInData.CreateProfiles())
            Assert.Equal(expected.PresetIds, profiles.Single(p => p.Id == expected.Id).PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(10, presets, profiles)); // once only
    }

    [Fact]
    public void Version_14_libraries_get_3d_model_presets_and_their_donut_after_data()
    {
        // As written with schema 14: no 3D formats.
        var modelIds = BuiltInData.ModelPresets().Select(p => p.Id).ToHashSet();
        var geoIds = BuiltInData.GeoPresets().Select(p => p.Id).ToHashSet();
        var presets = BuiltInData.CreatePresets().Where(p => !modelIds.Contains(p.Id) && !geoIds.Contains(p.Id)).ToList();
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id is not ("models" or "geo")).ToList();

        Assert.True(SettingsMigrations.ApplyToLibrary(14, presets, profiles));

        Assert.Equal(["to-glb", "to-stl", "to-obj", "to-3mf", "to-ply", "to-gltf"], presets.Where(p => modelIds.Contains(p.Id)).Select(p => p.Id));
        var ids = profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("data") + 1, ids.IndexOf("models"));
        Assert.Equal(ids.IndexOf("models") + 1, ids.IndexOf("geo")); // and, from schema 25, the geospatial donut
        Assert.Equal(ids.IndexOf("mixed") - 1, ids.IndexOf("geo"));
        var models = profiles.Single(p => p.Id == "models");
        Assert.Equal(["glb", "gltf", "stl", "obj", "3mf", "ply", "fbx"], models.Extensions);
        Assert.Equal(BuiltInData.ModelProfile().PresetIds, models.PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(14, presets, profiles)); // once only
    }

    [Fact]
    public void The_3d_donut_leaves_out_extensions_a_profile_of_the_user_takes()
    {
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id is not ("models" or "geo")).ToList();
        profiles.Insert(0, new ToolbarProfile { Id = "printing", Name = "Printing", Extensions = ["stl", "3mf"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(14, presets, profiles));

        Assert.Equal(["glb", "gltf", "obj", "ply", "fbx"], profiles.Single(p => p.Id == "models").Extensions);
    }

    [Fact]
    public void Version_21_libraries_learn_fbx_on_the_3d_donut_and_nothing_else()
    {
        // As written with schema 21: no FBX, and the user took PLY off the 3D donut.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var models = profiles.Single(p => p.Id == "models");
        models.Extensions.RemoveAll(e => e is "fbx" or "ply");

        Assert.True(SettingsMigrations.ApplyToLibrary(21, presets, profiles));

        Assert.Equal(["glb", "gltf", "stl", "obj", "3mf", "fbx"], models.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(21, presets, profiles)); // once only

        // A donut of the user that already opens FBX files keeps them.
        profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "models").Extensions.Remove("fbx");
        profiles.Insert(0, new ToolbarProfile { Id = "games", Name = "Games", Extensions = ["fbx"] });
        Assert.False(SettingsMigrations.ApplyToLibrary(21, presets, profiles));
        Assert.DoesNotContain("fbx", profiles.Single(p => p.Id == "models").Extensions);
    }

    [Fact]
    public void Version_22_libraries_learn_mhtml_on_the_text_donut_and_nothing_else()
    {
        // As written with schema 22: no MHTML, and the user took Markdown off the text donut.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var text = profiles.Single(p => p.Id == "text");
        text.Extensions.RemoveAll(e => e is "mhtml" or "mht" or "md" or "markdown");

        Assert.True(SettingsMigrations.ApplyToLibrary(22, presets, profiles));

        Assert.Contains("mhtml", text.Extensions);
        Assert.Contains("mht", text.Extensions);
        Assert.DoesNotContain("md", text.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(22, presets, profiles)); // once only

        // A donut of the user that already opens .mht files keeps them; .mhtml still goes to the text donut.
        profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "text").Extensions.RemoveAll(e => e is "mhtml" or "mht");
        profiles.Insert(0, new ToolbarProfile { Id = "web", Name = "Web", Extensions = ["mht"] });
        Assert.True(SettingsMigrations.ApplyToLibrary(22, presets, profiles));
        Assert.Equal(["mhtml"], profiles.Single(p => p.Id == "text").Extensions.Where(e => e.StartsWith("mht", StringComparison.Ordinal)));
    }

    [Fact]
    public void Version_23_libraries_learn_potm_on_the_presentation_donut_and_nothing_else()
    {
        // As written with schema 23: no POTM, and the user took ODP off the presentation donut.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var slides = profiles.Single(p => p.Id == "presentations");
        slides.Extensions.RemoveAll(e => e is "potm" or "odp");

        Assert.True(SettingsMigrations.ApplyToLibrary(23, presets, profiles));

        Assert.Contains("potm", slides.Extensions);
        Assert.DoesNotContain("odp", slides.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(23, presets, profiles)); // once only

        // A donut of the user that already opens .potm files keeps them.
        profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "presentations").Extensions.Remove("potm");
        profiles.Insert(0, new ToolbarProfile { Id = "templates", Name = "Templates", Extensions = ["potm"] });
        Assert.False(SettingsMigrations.ApplyToLibrary(23, presets, profiles));
        Assert.DoesNotContain("potm", profiles.Single(p => p.Id == "presentations").Extensions);
    }

    [Fact]
    public void Version_26_libraries_learn_ofd_on_the_office_donut_and_nothing_else()
    {
        // As written with schema 26: no OFD, and the user took RTF off the office donut.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var office = profiles.Single(p => p.Id == "office");
        office.Extensions.RemoveAll(e => e is "ofd" or "rtf");

        Assert.True(SettingsMigrations.ApplyToLibrary(26, presets, profiles));

        Assert.Contains("ofd", office.Extensions);
        Assert.DoesNotContain("rtf", office.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(26, presets, profiles)); // once only

        // A donut of the user that already opens .ofd files keeps them.
        profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "office").Extensions.Remove("ofd");
        profiles.Insert(0, new ToolbarProfile { Id = "invoices", Name = "Invoices", Extensions = ["ofd"] });
        Assert.False(SettingsMigrations.ApplyToLibrary(26, presets, profiles));
        Assert.DoesNotContain("ofd", profiles.Single(p => p.Id == "office").Extensions);
    }

    [Fact]
    public void Version_24_libraries_get_geospatial_presets_and_their_donut_after_models()
    {
        // As written with schema 24: no geospatial formats.
        var geoIds = BuiltInData.GeoPresets().Select(p => p.Id).ToHashSet();
        var presets = BuiltInData.CreatePresets().Where(p => !geoIds.Contains(p.Id)).ToList();
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id != "geo").ToList();

        Assert.True(SettingsMigrations.ApplyToLibrary(24, presets, profiles));

        Assert.Equal(["to-geojson", "to-shp", "to-kml", "to-gpx", "to-kmz"], presets.Where(p => geoIds.Contains(p.Id)).Select(p => p.Id));
        Assert.Equal(["geojson", "shp", "kml", "gpx"], presets.Where(p => geoIds.Contains(p.Id)).Select(p => p.TargetFormat).Take(4));
        var ids = profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("models") + 1, ids.IndexOf("geo"));
        Assert.Equal(ids.IndexOf("mixed") - 1, ids.IndexOf("geo"));
        var geo = profiles.Single(p => p.Id == "geo");
        Assert.Equal(["geojson", "kml", "kmz", "gpx", "shp", "fit"], geo.Extensions);
        Assert.Equal(BuiltInData.GeoProfile().PresetIds, geo.PresetIds);
        Assert.All(geo.PresetIds, id => Assert.Contains(presets, p => p.Id == id));
        Assert.False(SettingsMigrations.ApplyToLibrary(24, presets, profiles)); // once only
    }

    [Fact]
    public void The_geospatial_donut_leaves_out_extensions_a_profile_of_the_user_takes_and_is_skipped_when_all_are_taken()
    {
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id != "geo").ToList();
        profiles.Insert(0, new ToolbarProfile { Id = "earth", Name = "Earth", Extensions = ["kml", "kmz"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(24, presets, profiles));
        Assert.Equal(["geojson", "gpx", "shp", "fit"], profiles.Single(p => p.Id == "geo").Extensions);

        var taken = BuiltInData.CreateProfiles().Where(p => p.Id != "geo").ToList();
        taken.Insert(0, new ToolbarProfile { Id = "all", Name = "All", Extensions = ["geojson", "kml", "kmz", "gpx", "shp", "fit"] });
        var geoIds = BuiltInData.GeoPresets().Select(p => p.Id).ToHashSet();
        var withoutPresets = BuiltInData.CreatePresets().Where(p => !geoIds.Contains(p.Id)).ToList();

        Assert.True(SettingsMigrations.ApplyToLibrary(24, withoutPresets, taken)); // the presets are still added
        Assert.DoesNotContain(taken, p => p.Id == "geo");
        Assert.Contains(withoutPresets, p => p.Id == "to-shp");
    }

    [Fact]
    public void A_geospatial_donut_of_the_user_is_not_replaced()
    {
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var mine = profiles.Single(p => p.Id == "geo");
        mine.PresetIds = ["to-kml"];
        mine.Extensions = ["kml"];

        SettingsMigrations.ApplyToLibrary(24, presets, profiles);

        var geo = profiles.Single(p => p.Id == "geo");
        Assert.Equal(["to-kml"], geo.PresetIds);
        // The extensions of the default donut that no donut takes yet are added to it, after the user's own.
        Assert.Equal(["kml", "geojson", "kmz", "gpx", "shp", "fit"], geo.Extensions);
    }

    [Fact]
    public void Version_24_settings_get_the_geo_engine_after_the_3d_models_engine()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"),
            """{ "schemaVersion": 24, "enginePriority": ["magick", "cad", "model3d", "archive", "pandoc", "libreoffice"] }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.Equal(["magick", "cad", "model3d", "geo", "archive", "pandoc", "libreoffice"], store.Settings.EnginePriority);
        Assert.Equal(AppSettings.CurrentSchemaVersion, store.Settings.SchemaVersion);
    }

    [Fact]
    public void A_new_library_has_the_geospatial_donut_with_presets_that_exist()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();

        var ids = store.Profiles.Select(p => p.Id).ToList();
        Assert.Equal(ids.IndexOf("models") + 1, ids.IndexOf("geo"));
        var geo = store.Profiles.Single(p => p.Id == "geo");
        Assert.All(geo.PresetIds, id => Assert.NotNull(store.FindPreset(id)));
        Assert.Equal("shp", store.FindPreset("to-shp")!.TargetFormat);
        Assert.Equal("csv", store.FindPreset("to-csv")!.TargetFormat);
    }

    [Fact]
    public void Version_27_libraries_get_one_zip_on_the_archives_donut_after_extract()
    {
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var archives = profiles.Single(p => p.Id == "archives");
        archives.PresetIds.Remove("zip-all");

        Assert.True(SettingsMigrations.ApplyToLibrary(27, presets, profiles));
        Assert.Equal(["extract", "zip-all", "to-zip", "to-7z", "to-tgz", "to-tar"], archives.PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(27, presets, profiles)); // once only

        // A library without the preset (the user deleted it) doesn't get it back, and a full donut stays full.
        presets.RemoveAll(p => p.Id == "zip-all");
        archives.PresetIds.Remove("zip-all");
        Assert.False(SettingsMigrations.ApplyToLibrary(27, presets, profiles));
        Assert.DoesNotContain("zip-all", archives.PresetIds);

        presets = BuiltInData.CreatePresets();
        archives.PresetIds = [.. presets.Where(p => p.Id != "zip-all").Take(ToolbarProfile.MaxSlices).Select(p => p.Id)];
        Assert.False(SettingsMigrations.ApplyToLibrary(27, presets, profiles));
        Assert.DoesNotContain("zip-all", archives.PresetIds);
    }

    [Fact]
    public void Version_28_libraries_get_extract_live_video_on_no_donut_and_learn_livp()
    {
        // As written with schema 28: no "Extract Live Photo video", no .livp on the images donut, and the user took
        // HEIC off it.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "extract-motion");
        var profiles = BuiltInData.CreateProfiles();
        var images = profiles.Single(p => p.Id == "images");
        images.Extensions.RemoveAll(e => e is "livp" or "heic");

        Assert.True(SettingsMigrations.ApplyToLibrary(28, presets, profiles));

        var motion = presets.Single(p => p.Id == "extract-motion");
        Assert.True(motion.Media.ExtractMotionPhoto);
        Assert.Equal("mp4", motion.TargetFormat);
        Assert.Equal("extract-frames-jpg", presets[presets.IndexOf(motion) - 1].Id);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("extract-motion"));
        Assert.Contains("livp", images.Extensions);
        Assert.DoesNotContain("heic", images.Extensions);
        Assert.False(SettingsMigrations.ApplyToLibrary(28, presets, profiles)); // once only

        // Back from an older Filee, which dropped the option it didn't know: the preset extracts again, its name stays.
        motion.Media.ExtractMotionPhoto = false;
        motion.Name = "Live video";
        Assert.True(SettingsMigrations.ApplyToLibrary(28, presets, profiles));
        Assert.True(motion.Media.ExtractMotionPhoto);
        Assert.Equal("Live video", motion.Name);
        Assert.Single(presets, p => p.Id == "extract-motion");
    }

    [Fact]
    public void Version_30_libraries_get_the_live_photo_presets_after_extract_live_video_and_behind_the_video_donut()
    {
        // As written with schema 30: no Live / Motion Photo presets, and the video donut's back face without them.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id is "live-photo-iphone" or "motion-photo-android");
        var profiles = BuiltInData.CreateProfiles();
        var video = profiles.Single(p => p.Id == "video");
        video.BackPresetIds!.RemoveAll(id => id is "live-photo-iphone" or "motion-photo-android");

        Assert.True(SettingsMigrations.ApplyToLibrary(30, presets, profiles));

        var iphone = presets.Single(p => p.Id == "live-photo-iphone");
        var android = presets.Single(p => p.Id == "motion-photo-android");
        Assert.Equal((LivePhotoKind.Apple, "jpg"), (iphone.Media.LivePhoto, iphone.TargetFormat));
        Assert.Equal((LivePhotoKind.Android, "jpg"), (android.Media.LivePhoto, android.TargetFormat));
        // Where a new library has them, on no donut.
        Assert.Equal(BuiltInData.CreatePresets().Select(p => p.Id), presets.Select(p => p.Id));
        Assert.Equal("extract-motion", presets[presets.IndexOf(iphone) - 1].Id);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("live-photo-iphone") || p.PresetIds.Contains("motion-photo-android"));
        // Behind the video donut as in a new one, after "Extract frames".
        Assert.Equal(BuiltInData.CreateProfiles().Single(p => p.Id == "video").BackPresetIds, video.BackPresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(30, presets, profiles)); // once only

        // A back face the user filled up stays as it is.
        var full = BuiltInData.CreateProfiles();
        var fullBack = full.Single(p => p.Id == "video").BackPresetIds!;
        fullBack.RemoveAll(id => id is "live-photo-iphone" or "motion-photo-android");
        while (fullBack.Count < ToolbarProfile.MaxSlices)
            fullBack.Add("to-mp3");
        var before = fullBack.ToList();
        SettingsMigrations.ApplyToLibrary(30, BuiltInData.CreatePresets(), full);
        Assert.Equal(before, fullBack);

        // Back from an older Filee, which dropped the option it didn't know: the preset makes Live Photos again.
        iphone.Media.LivePhoto = LivePhotoKind.None;
        iphone.Name = "My Live Photo";
        Assert.True(SettingsMigrations.ApplyToLibrary(30, presets, profiles));
        Assert.Equal(LivePhotoKind.Apple, iphone.Media.LivePhoto);
        Assert.Equal("My Live Photo", iphone.Name);
        Assert.Single(presets, p => p.Id == "live-photo-iphone");
    }

    [Fact]
    public void Version_35_libraries_learn_icalendar_extensions_and_preset_without_overriding_user_choices()
    {
        using var fullDir = new TempDir();
        var full = new UserDataStore(fullDir.Path);
        full.Load();
        full.Settings.SchemaVersion = 35;
        var data = full.Profiles.Single(p => p.Id == "data");
        data.Extensions.RemoveAll(e => e is "ics" or "ical");
        full.Profiles.Insert(0, new ToolbarProfile { Id = "my-calendar", Name = "My calendar", Extensions = ["ics"] });
        var fullBack = full.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!;
        fullBack.Remove("to-ics");
        fullBack.AddRange(full.Presets.Select(p => p.Id).Where(id => !fullBack.Contains(id))
            .Take(ToolbarProfile.MaxSlices - fullBack.Count));
        var fullBackBeforeMigration = fullBack.ToList();
        full.Presets.RemoveAll(p => p.Id == "to-ics");
        full.SaveSettings();
        full.SaveLibrary();

        var upgradedFull = new UserDataStore(fullDir.Path);
        upgradedFull.Load();
        Assert.Contains("ical", upgradedFull.Profiles.Single(p => p.Id == "data").Extensions);
        Assert.DoesNotContain("ics", upgradedFull.Profiles.Single(p => p.Id == "data").Extensions);
        Assert.Contains("ics", upgradedFull.Profiles.Single(p => p.Id == "my-calendar").Extensions);
        Assert.Equal(fullBackBeforeMigration, upgradedFull.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds);
        Assert.Single(upgradedFull.Presets, p => p.Id == "to-ics");

        using var roomDir = new TempDir();
        var room = new UserDataStore(roomDir.Path);
        room.Load();
        room.Settings.SchemaVersion = 35;
        foreach (var profile in room.Profiles)
            profile.Extensions.RemoveAll(e => e is "ics" or "ical");
        room.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!.Remove("to-ics");
        room.Presets.RemoveAll(p => p.Id == "to-ics");
        room.SaveSettings();
        room.SaveLibrary();

        var upgradedRoom = new UserDataStore(roomDir.Path);
        upgradedRoom.Load();
        var sheets = upgradedRoom.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!;
        Assert.Equal(sheets.IndexOf("to-vcf") + 1, sheets.IndexOf("to-ics"));
        Assert.Single(upgradedRoom.Presets, p => p.Id == "to-ics");
        upgradedRoom.Profiles.Single(p => p.Id == "data").Extensions.Remove("ics");
        upgradedRoom.SaveLibrary();

        var reloadedRoom = new UserDataStore(roomDir.Path);
        reloadedRoom.Load();
        Assert.DoesNotContain("ics", reloadedRoom.Profiles.Single(p => p.Id == "data").Extensions);
        Assert.Equal(1, reloadedRoom.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!.Count(id => id == "to-ics"));
        Assert.Single(reloadedRoom.Presets, p => p.Id == "to-ics");

        using var deletedDir = new TempDir();
        var deleted = new UserDataStore(deletedDir.Path);
        deleted.Load();
        deleted.Settings.SchemaVersion = 35;
        deleted.Profiles.RemoveAll(p => p.Id == "data");
        foreach (var profile in deleted.Profiles)
            profile.Extensions.RemoveAll(e => e is "ics" or "ical");
        deleted.Profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!.Remove("to-ics");
        deleted.Presets.RemoveAll(p => p.Id == "to-ics");
        deleted.SaveSettings();
        deleted.SaveLibrary();

        var upgradedDeleted = new UserDataStore(deletedDir.Path);
        upgradedDeleted.Load();
        Assert.DoesNotContain(upgradedDeleted.Profiles, p => p.Id == "data");
        Assert.DoesNotContain(upgradedDeleted.Profiles.SelectMany(p => p.Extensions), e => e is "ics" or "ical");
        Assert.Single(upgradedDeleted.Presets, p => p.Id == "to-ics");
    }

    [Fact]
    public void Live_photo_options_survive_saving_and_unknown_kinds_read_as_none()
    {
        var preset = new Preset
        {
            TargetFormat = "heic",
            Media = { LivePhoto = LivePhotoKind.Apple, LivePhotoStart = 2.5, LivePhotoLength = 2, LivePhotoCover = 0.5 },
        };
        var json = System.Text.Json.JsonSerializer.Serialize(preset, FileeJsonContext.Default.Preset);
        Assert.Contains("\"livePhoto\": \"Apple\"", json);
        var read = System.Text.Json.JsonSerializer.Deserialize(json, FileeJsonContext.Default.Preset)!;
        Assert.Equal((LivePhotoKind.Apple, 2.5, 2.0, 0.5),
            (read.Media.LivePhoto, read.Media.LivePhotoStart, read.Media.LivePhotoLength, read.Media.LivePhotoCover));

        // A kind of a newer Filee: still one preset that loads, as a plain conversion.
        var future = System.Text.Json.JsonSerializer.Deserialize(json.Replace("\"Apple\"", "\"Hologram\""), FileeJsonContext.Default.Preset)!;
        Assert.Equal(LivePhotoKind.None, future.Media.LivePhoto);
    }

    [Fact]
    public void Version_15_libraries_get_the_tracing_presets_on_the_images_donut_after_pdf()
    {
        // As written before tracing: no trace presets, and the images donut without them.
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id is "trace-svg" or "trace-line-art");
        var profiles = BuiltInData.CreateProfiles();
        var images = profiles.Single(p => p.Id == "images");
        images.PresetIds.RemoveAll(id => id is "trace-svg" or "trace-line-art");

        Assert.True(SettingsMigrations.ApplyToLibrary(15, presets, profiles));

        Assert.Equal(TracingMode.Color, presets.Single(p => p.Id == "trace-svg").Trace.Mode);
        Assert.Equal(TracingMode.BlackAndWhite, presets.Single(p => p.Id == "trace-line-art").Trace.Mode);
        Assert.All(presets.Where(p => p.Id.StartsWith("trace-", StringComparison.Ordinal)), p => Assert.Equal("svg", p.TargetFormat));
        Assert.Equal(BuiltInData.CreateProfiles().Single(p => p.Id == "images").PresetIds, images.PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(15, presets, profiles)); // once only
    }

    [Fact]
    public void Trace_options_survive_a_save_and_load()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        var preset = store.Presets.Single(p => p.Id == "trace-svg");
        preset.Trace.Colors = 6;
        preset.Trace.Detail = 80;
        store.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        var trace = reloaded.Presets.Single(p => p.Id == "trace-svg").Trace;
        Assert.Equal((TracingMode.Color, 6, 80), (trace.Mode, trace.Colors, trace.Detail));
        Assert.Equal(TracingMode.BlackAndWhite, reloaded.Presets.Single(p => p.Id == "trace-line-art").Trace.Mode);
    }

    [Fact]
    public void Version_16_libraries_get_rotate_and_flip_presets_and_groups_on_no_donut()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id is "rotate-left" or "rotate-right" or "rotate-180" or "flip-horizontal" or "flip-vertical" or "rotate" or "flip");
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(16, presets, profiles));

        var rotate = presets.Single(p => p.Id == "rotate");
        Assert.True(rotate.IsGroup);
        Assert.Equal(["rotate-left", "rotate-right", "rotate-180"], rotate.SubPresetIds);
        Assert.Equal(ImageRotation.Left90, presets.Single(p => p.Id == "rotate-left").Image.Rotation);
        Assert.Equal(ImageFlip.Horizontal, presets.Single(p => p.Id == "flip-horizontal").Image.Flip);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Any(id => id.StartsWith("rotate") || id.StartsWith("flip")));
        Assert.False(SettingsMigrations.ApplyToLibrary(16, presets, profiles)); // once only
        // Where a new library has them: after "Remove background".
        var background = presets.FindIndex(p => p.Id == "remove-background");
        Assert.Equal("rotate-left", presets[background + 1].Id);
    }

    /// <summary>Presets and donuts as a Filee before PDF → PPTX wrote them (schema 17).</summary>
    private static (List<Preset> Presets, List<ToolbarProfile> Profiles) Version17Library()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "pdf-slides");
        var profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "pdf").PresetIds = [.. BuiltInData.PdfDonutBefore18];
        return (presets, profiles);
    }

    [Fact]
    public void Version_17_libraries_get_pptx_slides_on_the_unchanged_pdf_donut_in_place_of_tiff()
    {
        var (presets, profiles) = Version17Library();

        Assert.True(SettingsMigrations.ApplyToLibrary(17, presets, profiles));

        var slides = presets.Single(p => p.Id == "pdf-slides");
        Assert.Equal(("pptx", "preset.pdf_slides"), (slides.TargetFormat, slides.NameKey));
        Assert.Equal("pdf-split", presets[presets.IndexOf(slides) - 1].Id); // where a new library has it
        var pdf = profiles.Single(p => p.Id == "pdf").PresetIds;
        Assert.Equal(BuiltInData.CreateProfiles().Single(p => p.Id == "pdf").PresetIds, pdf);
        Assert.Equal(pdf.IndexOf("to-docx") + 1, pdf.IndexOf("pdf-slides"));
        Assert.DoesNotContain("to-tiff", pdf);
        Assert.NotNull(presets.SingleOrDefault(p => p.Id == "to-tiff")); // still a preset to add again
        Assert.False(SettingsMigrations.ApplyToLibrary(17, presets, profiles)); // once only
    }

    [Fact]
    public void A_pdf_donut_the_user_changed_gets_pptx_slides_only_when_it_has_room()
    {
        // Full, but not the default: the user's choice of twelve stays.
        var (presets, profiles) = Version17Library();
        var pdf = profiles.Single(p => p.Id == "pdf");
        pdf.PresetIds[pdf.PresetIds.IndexOf("to-tiff")] = "to-webp";

        Assert.True(SettingsMigrations.ApplyToLibrary(17, presets, profiles)); // the preset is added
        Assert.DoesNotContain("pdf-slides", pdf.PresetIds);
        Assert.Contains("to-webp", pdf.PresetIds);

        // With room: after DOCX.
        (presets, profiles) = Version17Library();
        pdf = profiles.Single(p => p.Id == "pdf");
        pdf.PresetIds.RemoveAll(id => id is "to-md" or "to-epub");

        Assert.True(SettingsMigrations.ApplyToLibrary(17, presets, profiles));
        Assert.Equal(pdf.PresetIds.IndexOf("to-docx") + 1, pdf.PresetIds.IndexOf("pdf-slides"));
        Assert.Contains("to-tiff", pdf.PresetIds);
    }

    [Fact]
    public void Version_17_settings_get_the_pdf_slides_engine_after_pdf_text()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"),
            """{ "schemaVersion": 17, "enginePriority": ["magick", "pdfium", "docx-writer", "pdf-text", "email", "pandoc", "libreoffice"] }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.Equal(["magick", "pdfium", "docx-writer", "pdf-text", "pdf-slides", "email", "geo", "wic", "pandoc", "libreoffice"], store.Settings.EnginePriority);
        Assert.Equal(AppSettings.CurrentSchemaVersion, store.Settings.SchemaVersion);
    }

    [Fact]
    public void Version_20_settings_get_the_wic_engine_after_the_other_built_in_engines()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"),
            """{ "schemaVersion": 20, "enginePriority": ["magick", "pdfium", "hwpx-writer", "subtitle", "ffmpeg", "pandoc", "libreoffice"] }""");

        var store = new UserDataStore(dir.Path);
        store.Load();

        // Not near the top: the HWPX writer stays among the ranks that win ties (see EbookTests).
        Assert.Equal(["magick", "pdfium", "hwpx-writer", "subtitle", "wic", "ffmpeg", "geo", "pandoc", "libreoffice"], store.Settings.EnginePriority);
        Assert.Equal(AppSettings.CurrentSchemaVersion, store.Settings.SchemaVersion);
    }

    [Fact]
    public void Version_20_libraries_open_jpeg_xr_on_the_images_donut()
    {
        // As written with schema 20: no JPEG XR yet; the user took PSD off the images donut and has a donut for .wdp.
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var images = profiles.Single(p => p.Id == "images");
        images.Extensions.RemoveAll(e => e is "jxr" or "wdp" or "hdp" or "psd");
        profiles.Insert(0, new ToolbarProfile { Id = "photos", Name = "Windows Photo Gallery", Extensions = ["wdp"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(20, presets, profiles));

        Assert.Contains("jxr", images.Extensions);
        Assert.Contains("hdp", images.Extensions);
        Assert.DoesNotContain("wdp", images.Extensions);
        Assert.DoesNotContain("psd", images.Extensions); // only the new extensions are learnt
        Assert.False(SettingsMigrations.ApplyToLibrary(20, presets, profiles)); // once only
    }

    [Fact]
    public void The_close_action_is_saved_and_one_from_a_newer_Filee_reads_as_ask()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        Assert.Equal(CloseAction.Ask, store.Settings.CloseAction);
        store.Settings.CloseAction = CloseAction.Quit;
        store.SaveSettings();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(CloseAction.Quit, reloaded.Settings.CloseAction);

        var path = Path.Combine(dir.Path, "settings.json");
        var json = File.ReadAllText(path);
        Assert.Contains("\"closeAction\": \"Quit\"", json);
        File.WriteAllText(path, json.Replace("\"closeAction\": \"Quit\"", "\"closeAction\": \"Minimize\""));
        var newer = new UserDataStore(dir.Path);
        newer.Load();
        Assert.Equal(CloseAction.Ask, newer.Settings.CloseAction);
        Assert.False(File.Exists(path + ".broken"));
    }

    [Fact]
    public void A_rotation_from_a_newer_Filee_reads_as_none_and_the_other_presets_still_load()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.SaveLibrary();
        var path = Path.Combine(dir.Path, "presets.json");
        var json = File.ReadAllText(path);
        Assert.Contains("\"rotation\": \"Left90\"", json);
        File.WriteAllText(path, json.Replace("\"rotation\": \"Left90\"", "\"rotation\": \"Transpose\"")
            .Replace("\"flip\": \"Vertical\"", "\"flip\": 7"));

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();

        Assert.Equal(ImageRotation.None, reloaded.FindPreset("rotate-left")!.Image.Rotation);
        Assert.Equal(ImageFlip.None, reloaded.FindPreset("flip-vertical")!.Image.Flip);
        Assert.Equal(ImageRotation.Right90, reloaded.FindPreset("rotate-right")!.Image.Rotation); // the rest as saved
        Assert.False(File.Exists(path + ".broken"));
    }

    [Fact]
    public void Back_from_an_older_Filee_rotate_and_flip_work_again_and_keep_the_users_changes()
    {
        // What a Filee before 17 leaves after saving: kind, members and rotation dropped, the rest as it was.
        var presets = BuiltInData.CreatePresets();
        var left = presets.Single(p => p.Id == "rotate-left");
        left.Image.Rotation = ImageRotation.None;
        left.Name = "Turn left";
        var rotate = presets.Single(p => p.Id == "rotate");
        rotate.Kind = PresetKind.Convert;
        rotate.SubPresetIds = [];
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(16, presets, profiles));

        Assert.Equal(ImageRotation.Left90, left.Image.Rotation);
        Assert.Equal("Turn left", left.Name);
        Assert.True(rotate.IsGroup);
        Assert.Equal(["rotate-left", "rotate-right", "rotate-180"], rotate.SubPresetIds);
        Assert.Equal(Preset.GroupTarget, rotate.TargetFormat);
        Assert.Single(presets, p => p.Id == "rotate-left"); // repaired, not added twice
    }

    [Fact]
    public void Version_17_libraries_get_compress_pdf_after_split_pdf_on_no_donut()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "compress-pdf");
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(17, presets, profiles));

        var compress = presets.Single(p => p.Id == "compress-pdf");
        Assert.Equal(("pdf", PdfCompression.Ebook, false), (compress.TargetFormat, compress.Pdf.Compression, compress.Pdf.CompressWithGhostscript));
        Assert.Equal("pdf-split", presets[presets.IndexOf(compress) - 1].Id); // where a new library has it
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("compress-pdf"));
        Assert.Equal(BuiltInData.CreateProfiles().Single(p => p.Id == "pdf").PresetIds, profiles.Single(p => p.Id == "pdf").PresetIds);
        Assert.False(SettingsMigrations.ApplyToLibrary(17, presets, profiles)); // once only
    }

    [Fact]
    public void Version_25_libraries_get_crop_tool_preset_after_remove_background_on_no_donut()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "tool-crop");
        var profiles = BuiltInData.CreateProfiles();

        Assert.True(SettingsMigrations.ApplyToLibrary(25, presets, profiles));

        var crop = presets.Single(p => p.Id == "tool-crop");
        Assert.Equal(PresetKind.Tool, crop.Kind);
        Assert.Equal("remove-background", presets[presets.IndexOf(crop) - 1].Id);
        Assert.DoesNotContain(profiles, p => p.PresetIds.Contains("tool-crop"));
        Assert.False(SettingsMigrations.ApplyToLibrary(25, presets, profiles)); // once only
    }

    [Fact]
    public void Version_41_libraries_get_the_spreadsheet_print_studio_after_crop_and_on_the_back()
    {
        var presets = BuiltInData.CreatePresets();
        presets.RemoveAll(p => p.Id == "tool-sheet-studio");
        var profiles = BuiltInData.CreateProfiles();
        profiles.Single(p => p.Id == "spreadsheets").BackPresetIds!.Remove("tool-sheet-studio");

        Assert.True(SettingsMigrations.ApplyToLibrary(41, presets, profiles));

        var studio = presets.Single(p => p.Id == "tool-sheet-studio");
        Assert.Equal((PresetKind.Tool, "pdf"), (studio.Kind, studio.TargetFormat));
        Assert.Equal(presets.FindIndex(p => p.Id == "tool-crop") + 1, presets.IndexOf(studio)); // as in a new library
        Assert.Equal("tool-sheet-studio", profiles.Single(p => p.Id == "spreadsheets").BackPresetIds![0]);
        Assert.False(SettingsMigrations.ApplyToLibrary(41, presets, profiles));
    }

    [Fact]
    public void Version_41_libraries_keep_the_print_studio_off_the_back_when_the_front_has_it()
    {
        var presets = BuiltInData.CreatePresets();
        var profiles = BuiltInData.CreateProfiles();
        var spreadsheets = profiles.Single(p => p.Id == "spreadsheets");
        spreadsheets.BackPresetIds!.Remove("tool-sheet-studio");
        spreadsheets.PresetIds.Add("tool-sheet-studio"); // the user put it on the front

        SettingsMigrations.ApplyToLibrary(41, presets, profiles);

        Assert.DoesNotContain("tool-sheet-studio", spreadsheets.BackPresetIds);
        Assert.Single(presets, p => p.Id == "tool-sheet-studio");
    }

    [Fact]
    public void Back_from_an_older_Filee_tool_crop_works_again_and_keeps_the_users_changes()
    {
        // What a Filee before 26 leaves after saving: kind read as Group, TargetFormat dropped, SubPresetIds empty, the rest as it was.
        var presets = BuiltInData.CreatePresets();
        var crop = presets.Single(p => p.Id == "tool-crop");
        crop.Kind = PresetKind.Group;
        crop.TargetFormat = Preset.GroupTarget;
        crop.SubPresetIds = [];
        crop.Name = "Trim";

        Assert.True(SettingsMigrations.ApplyToLibrary(25, presets, BuiltInData.CreateProfiles()));

        Assert.Equal(PresetKind.Tool, crop.Kind);
        Assert.Equal(BuiltInData.SameAsSource, crop.TargetFormat);
        Assert.Empty(crop.SubPresetIds);
        Assert.Equal("Trim", crop.Name);
        Assert.Single(presets, p => p.Id == "tool-crop");
    }

    [Fact]
    public void Back_from_an_older_Filee_compress_pdf_compresses_again_and_keeps_the_users_changes()
    {
        // What a Filee before 20 leaves after saving: the compression level dropped, the rest as it was.
        var presets = BuiltInData.CreatePresets();
        var compress = presets.Single(p => p.Id == "compress-pdf");
        compress.Pdf.Compression = PdfCompression.None;
        compress.Name = "Shrink";

        Assert.True(SettingsMigrations.ApplyToLibrary(17, presets, BuiltInData.CreateProfiles()));

        Assert.Equal(PdfCompression.Ebook, compress.Pdf.Compression);
        Assert.Equal("Shrink", compress.Name);
        Assert.Single(presets, p => p.Id == "compress-pdf");
    }

    [Fact]
    public void Pdf_compression_survives_a_save_and_load_and_a_newer_level_reads_as_none()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        var preset = store.Presets.Single(p => p.Id == "compress-pdf");
        preset.Pdf.Compression = PdfCompression.Print;
        preset.Pdf.CompressWithGhostscript = true;
        store.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        var pdf = reloaded.Presets.Single(p => p.Id == "compress-pdf").Pdf;
        Assert.Equal((PdfCompression.Print, true), (pdf.Compression, pdf.CompressWithGhostscript));

        var path = Path.Combine(dir.Path, "presets.json");
        File.WriteAllText(path, File.ReadAllText(path).Replace("\"compression\": \"Print\"", "\"compression\": \"Extreme\""));
        var newer = new UserDataStore(dir.Path);
        newer.Load();
        Assert.Equal(PdfCompression.None, newer.FindPreset("compress-pdf")!.Pdf.Compression);
        Assert.False(File.Exists(path + ".broken"));
    }

    [Fact]
    public void Catalog_migration_ignores_extensions_checked_on_mixed_profiles()
    {
        // Schema-5 data where the user already limited a mixed-files donut to MP3 and JPG: those checks must not
        // count as "taken" when the catalog donuts and extensions are added.
        var presets = BuiltInData.CreatePresets().Where(p => BuiltInData.CatalogPresets().All(c => c.Id != p.Id)).ToList();
        var catalogIds = BuiltInData.CatalogProfiles().Select(p => p.Id).Append("models").Append("geo").ToHashSet();
        var profiles = BuiltInData.CreateProfiles().Where(p => !catalogIds.Contains(p.Id)).ToList();
        profiles.Single(p => p.Id == "images").Extensions = ["png"];
        profiles.Add(new ToolbarProfile { Id = "music-mix", Name = "Music mix", IsFallback = true, Extensions = ["mp3", "jpg"] });

        Assert.True(SettingsMigrations.ApplyToLibrary(5, presets, profiles));

        Assert.Contains("mp3", profiles.Single(p => p.Id == "audio").Extensions);
        Assert.Contains("jpg", profiles.Single(p => p.Id == "images").Extensions);
        Assert.Equal(["mp3", "jpg"], profiles.Single(p => p.Id == "music-mix").Extensions);
    }

    [Fact]
    public void Several_mixed_profiles_are_kept_and_one_is_added_when_none_is_left()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Profiles.Add(new ToolbarProfile { Id = "scans", Name = "Scans", IsFallback = true, Extensions = ["jpg", "pdf"] });
        store.SaveLibrary();

        var reloaded = new UserDataStore(dir.Path);
        reloaded.Load();
        Assert.Equal(["mixed", "scans"], reloaded.Profiles.Where(p => p.IsFallback).Select(p => p.Id));

        reloaded.Profiles.RemoveAll(p => p.IsFallback);
        reloaded.SaveLibrary();
        Assert.Equal("mixed", Assert.Single(reloaded.Profiles, p => p.IsFallback).Id);
    }

    [Fact]
    public void Imported_mixed_profiles_stay_mixed()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Profiles.Add(new ToolbarProfile { Id = "scans", Name = "Scans", IsFallback = true, Extensions = ["jpg", "pdf"] });
        var bundle = Path.Combine(dir.Path, "bundle.json");
        store.Export(bundle);

        using var other = new TempDir();
        var target = new UserDataStore(other.Path);
        target.Load();
        target.Import(bundle);

        Assert.True(target.Profiles.Single(p => p.Id == "scans").IsFallback);
        Assert.Single(target.Profiles, p => p.Id == "mixed");
        Assert.Equal("scans", ProfileSelector.Select(target.Profiles, ["a.jpg", "b.pdf"])!.Id);
        Assert.Equal("mixed", ProfileSelector.Select(target.Profiles, ["a.jpg", "b.docx"])!.Id);
    }

    [Fact]
    public void Spreadsheet_profile_is_not_added_when_a_user_profile_takes_spreadsheets()
    {
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id is not ("spreadsheets" or "presentations")).ToList();
        profiles.Insert(0, new ToolbarProfile { Id = "mine", Name = "Mine", Extensions = ["xlsx"] });

        SettingsMigrations.ApplyToLibrary(4, BuiltInData.CreatePresets(), profiles);

        Assert.DoesNotContain(profiles, p => p.Id == "spreadsheets");
        Assert.Contains(profiles, p => p.Id == "presentations");
        Assert.Equal(["xlsx"], profiles[0].Extensions);
    }

    [Fact]
    public void Text_profile_is_not_added_when_a_profile_already_takes_markdown()
    {
        var profiles = BuiltInData.CreateProfiles().Where(p => p.Id != "text").ToList();
        profiles[0].Extensions.Add("md");

        SettingsMigrations.ApplyToLibrary(3, BuiltInData.CreatePresets(), profiles);
        Assert.DoesNotContain(profiles, p => p.Id == "text");
    }

    [Fact]
    public void Enums_are_stored_as_strings()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.SaveSettings();

        var json = File.ReadAllText(Path.Combine(dir.Path, "settings.json"));
        Assert.Contains("\"Drag\"", json);
    }

    [Fact]
    public void Corrupt_file_falls_back_to_defaults_and_is_kept()
    {
        using var dir = new TempDir();
        File.WriteAllText(Path.Combine(dir.Path, "presets.json"), "{ not json");
        File.WriteAllText(Path.Combine(dir.Path, "settings.json"), "{ not json");

        var store = new UserDataStore(dir.Path);
        store.Load();

        Assert.NotEmpty(store.Presets);
        Assert.True(store.Settings.ShowInDock);
        Assert.True(store.Settings.ShowMenuBarIcon);
        Assert.True(File.Exists(Path.Combine(dir.Path, "presets.json.broken")));
        Assert.True(File.Exists(Path.Combine(dir.Path, "settings.json.broken")));
    }

    [Fact]
    public void Dangling_preset_references_are_removed()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Profiles[0].PresetIds.Add("does-not-exist");
        store.SaveLibrary();

        Assert.DoesNotContain("does-not-exist", store.Profiles[0].PresetIds);
    }

    [Fact]
    public void Export_then_import_restores_presets()
    {
        using var dir = new TempDir();
        var store = new UserDataStore(dir.Path);
        store.Load();
        store.Presets.Add(new Preset { Id = "shared", Name = "Shared", TargetFormat = "png" });
        var bundle = Path.Combine(dir.Path, "bundle.json");
        store.Export(bundle);

        using var other = new TempDir();
        var target = new UserDataStore(other.Path);
        target.Load();
        target.Import(bundle);

        Assert.NotNull(target.FindPreset("shared"));
        Assert.Single(target.Profiles, p => p.IsFallback);
    }
}