Drops the unreachable "Custom only" text: every codec of this PC has built-in presets. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
189 lines
9.5 KiB
C#
189 lines
9.5 KiB
C#
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using Titano.App.Settings;
|
|
using Titano.Core.Localization;
|
|
using Titano.Core.Naming;
|
|
using Titano.Core.Video;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.App.Tests.Settings;
|
|
|
|
public sealed class SettingsLogicTests
|
|
{
|
|
public SettingsLogicTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
|
|
|
|
[Test]
|
|
public void DefaultTemplatesPreviewThreeNames()
|
|
{
|
|
var names = NamingPreview.FirstNames(TemplateDefaults.Folder, TemplateDefaults.File);
|
|
Assert.SequenceEqual(
|
|
[
|
|
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-11_0001.CR2",
|
|
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-13_0002.CR2",
|
|
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-15_0003.CR2",
|
|
],
|
|
names);
|
|
Assert.Null(NamingPreview.Validate(TemplateDefaults.Folder, isFolder: true));
|
|
Assert.Null(NamingPreview.Validate(TemplateDefaults.File, isFolder: false));
|
|
}
|
|
|
|
[Theory]
|
|
[Case("{date}_{time}_{n:0000", "Errors.Template.UnclosedBrace", "", 15)]
|
|
[Case("{date}_{nope}", "Errors.Template.UnknownToken", "nope", 8)]
|
|
[Case("{}_{n}", "Errors.Template.EmptyToken", "", 1)]
|
|
[Case("{n}}x", "Errors.Template.UnopenedBrace", "", 4)]
|
|
[Case(" ", "Errors.Template.Empty", "", 1)]
|
|
[Case("{date}", "Errors.Template.NotUnique", "", 0)]
|
|
[Case("{year}/{n}", "Errors.Template.FileSeparator", "", 0)]
|
|
[Case("{date:%}_{n}", "Errors.Template.Format", "", 0)]
|
|
public void InvalidFileTemplatesExplainTheProblem(string template, string key, string token, int position)
|
|
{
|
|
var expected = position > 0 ? Loc.L(key, token, position) : Loc.L(key);
|
|
Assert.Equal(expected, NamingPreview.Validate(template, isFolder: false), template);
|
|
Assert.Empty(NamingPreview.FirstNames(TemplateDefaults.Folder, template));
|
|
}
|
|
|
|
[Test]
|
|
public void TemplateErrorsNameThePosition()
|
|
{
|
|
Assert.Equal("The brace opened at position 8 is never closed.", NamingPreview.Validate("{date}_{time", isFolder: false));
|
|
Assert.Equal("Unknown token “nope” at position 8.", NamingPreview.Validate("{date}_{nope}", isFolder: false));
|
|
}
|
|
|
|
[Test]
|
|
public void FolderTemplatesMayNestAndRepeat()
|
|
{
|
|
Assert.Null(NamingPreview.Validate("{year}/{month}/{camera}", isFolder: true));
|
|
Assert.Equal("2026/09/Canon EOS R5/IMG_4211.CR2", NamingPreview.FirstNames("{year}/{month}/{camera}", "{name}")[0]);
|
|
}
|
|
|
|
[Test]
|
|
public void EnterCommitsAndEscReverts()
|
|
{
|
|
string? stored = null;
|
|
var field = new EditableField("8", v => int.TryParse(v, out var n) && n is >= 1 and <= 32 ? null : "1 to 32", v => stored = v, () => "Worker threads");
|
|
var changes = new List<string?>();
|
|
field.PropertyChanged += (_, e) => changes.Add(e.PropertyName);
|
|
var errors = 0;
|
|
field.ErrorsChanged += (_, _) => errors++;
|
|
|
|
field.Text = "12";
|
|
Assert.True(field.IsDirty);
|
|
Assert.False(field.HasErrors);
|
|
Assert.Equal("Worker threads", field.ToolTip);
|
|
Assert.True(field.Commit());
|
|
Assert.Equal("12", stored);
|
|
Assert.Equal("12", field.Value);
|
|
Assert.False(field.IsDirty);
|
|
|
|
field.Text = "99";
|
|
Assert.True(field.HasErrors);
|
|
Assert.Equal("1 to 32", field.ToolTip);
|
|
Assert.Equal("1 to 32", ((IEnumerable<string>)field.GetErrors(nameof(EditableField.Text))).Single());
|
|
Assert.False(field.Commit());
|
|
Assert.Equal("12", stored);
|
|
|
|
field.Revert();
|
|
Assert.Equal("12", field.Text);
|
|
Assert.False(field.HasErrors);
|
|
Assert.False(field.IsDirty);
|
|
Assert.Equal(2, errors);
|
|
Assert.Contains(nameof(EditableField.ToolTip), changes);
|
|
}
|
|
|
|
[Test]
|
|
public void LoadReplacesTheValueWithoutCommitting()
|
|
{
|
|
var commits = 0;
|
|
var field = new EditableField("a", v => v.Length == 0 ? "empty" : null, _ => commits++, () => "tip");
|
|
field.Load("b");
|
|
Assert.Equal("b", field.Value);
|
|
Assert.Equal("b", field.Text);
|
|
Assert.False(field.IsDirty);
|
|
Assert.Equal(0, commits);
|
|
Assert.True(field.Commit());
|
|
Assert.Equal(0, commits); // nothing changed, nothing stored
|
|
field.Load(string.Empty);
|
|
Assert.True(field.HasErrors);
|
|
}
|
|
|
|
[Test]
|
|
public void TheLanguageListHasEveryShippedCatalog()
|
|
{
|
|
var available = LanguageCatalog.Available;
|
|
Assert.Equal("en", available[0].Code);
|
|
Assert.Equal(available.Count, available.Select(l => l.Code).Distinct(StringComparer.OrdinalIgnoreCase).Count());
|
|
foreach (var option in available)
|
|
{
|
|
Assert.Contains(option.Code, Languages.Shipped);
|
|
Assert.True(LanguageCatalog.HasResources(option.Code), option.Code);
|
|
Assert.False(string.IsNullOrWhiteSpace(option.Name));
|
|
}
|
|
|
|
// Every culture folder of the catalog is offered, and nothing else.
|
|
var folders = Directory.EnumerateDirectories(Path.Combine(TestContext.RepositoryRoot, "i18n"))
|
|
.Select(Path.GetFileName)
|
|
.Where(n => n is not null && Directory.EnumerateFiles(Path.Combine(TestContext.RepositoryRoot, "i18n", n), "*.resx").Any())
|
|
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
Assert.Contains("it", folders);
|
|
Assert.SequenceEqual(folders.Order(StringComparer.OrdinalIgnoreCase), available.Select(o => o.Code).Order(StringComparer.OrdinalIgnoreCase));
|
|
Assert.Equal("Italiano", available.Single(o => o.Code == "it").Name);
|
|
Assert.Equal("it", LanguageCatalog.Match(CultureInfo.GetCultureInfo("it-CH")).Code);
|
|
Assert.Equal("en", LanguageCatalog.Match(CultureInfo.GetCultureInfo("sw")).Code);
|
|
}
|
|
|
|
[Test]
|
|
public void EachEncoderNamesThePresetsItServes()
|
|
{
|
|
var hevc = new EncoderRow("HEVC", "NVIDIA HEVC Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, true, 8192, 8192, VideoCodec.Hevc);
|
|
var av1 = hevc with { Codec = "AV1", Name = "NVIDIA AV1 Encoder MFT", VideoCodec = VideoCodec.Av1 };
|
|
var h264 = new EncoderRow("H.264", "H264 Encoder MFT", "Microsoft", EncoderSource.MediaFoundation, false, false, 4096, 2304, VideoCodec.H264);
|
|
var animation = new EncoderRow("GIF · APNG", "Titano", null, EncoderSource.BuiltInAnimation, false, false, 0, 0, null);
|
|
|
|
Assert.SequenceEqual(["8K archive", "4K archive", "4K HEVC", "DCI 4K", "Cinema 21:9", "4K 60 fps"], EncoderUse.Presets(hevc));
|
|
Assert.Equal("Animated GIF · Animated PNG", EncoderUse.Text(animation));
|
|
Assert.Contains("Share 1080p", EncoderUse.Presets(h264));
|
|
Assert.Equal("4K AV1", EncoderUse.Text(av1));
|
|
}
|
|
|
|
[Test]
|
|
public void ARenderNodeOffersHardwareEncodersOnlyWhenRendersMayUseThem()
|
|
{
|
|
EncoderRow[] rows =
|
|
[
|
|
new("HEVC", "NVIDIA HEVC Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, true, 8192, 8192, VideoCodec.Hevc),
|
|
new("H.264", "NVIDIA H.264 Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, false, 4096, 4096, VideoCodec.H264),
|
|
new("H.264", "H264 Encoder MFT", "Microsoft", EncoderSource.MediaFoundation, false, false, 4096, 2304, VideoCodec.H264),
|
|
new("MJPEG · AVI", "Titano", null, EncoderSource.BuiltInMjpeg, false, false, 0, 0, VideoCodec.Mjpeg),
|
|
];
|
|
|
|
Assert.Equal("HEVC · H.264", EncoderUse.Codecs(EncoderUse.Node(rows, allowsHardware: true)));
|
|
Assert.Equal(3, EncoderUse.Node(rows, allowsHardware: true).Count);
|
|
Assert.Equal("H.264", EncoderUse.Codecs(EncoderUse.Node(rows, allowsHardware: false)));
|
|
Assert.Null(EncoderUse.Codecs([]));
|
|
}
|
|
|
|
[Test]
|
|
public void EnumDrivenKeysExistInEveryRequiredLanguage()
|
|
{
|
|
var keys = new List<string>();
|
|
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobKind>().Select(k => "Jobs.Kind." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobState>().Select(k => "Jobs.State." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobState>().Select(k => "Tooltips.Jobs.State." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.App.Jobs.JobFilter>().SelectMany(k => new[] { "Jobs.Filter." + k, "Tooltips.Jobs.Filter." + k }));
|
|
keys.AddRange(Enum.GetNames<Titano.App.Library.StatusFilter>().Where(k => k != "Any").Select(k => "Library.Filter.Status." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.Data.Repositories.SequenceSort>().Select(k => "Library.Sort." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.App.Server.ConnectError>().Where(k => k != "None").Select(k => "Server.Error." + k));
|
|
keys.AddRange(Enum.GetNames<Titano.Core.Model.UserRole>().SelectMany(k => new[] { "Server.Role." + k, "Tooltips.Server.Role." + k }));
|
|
keys.AddRange(Enum.GetNames<SettingsPage>().SelectMany(k => new[] { "Settings.Page." + k, "Tooltips.Settings.Page." + k }));
|
|
keys.AddRange(Enum.GetNames<Titano.App.Infrastructure.QualityProfile>().Select(k => "Settings.Rendering.Quality." + k));
|
|
keys.AddRange(new[] { "UnclosedBrace", "EmptyToken", "UnknownToken", "UnopenedBrace", "Empty" }.Select(k => "Errors.Template." + k));
|
|
// Italian completeness is checked by `Titano.Tools i18n check`; here every enum value must have its key.
|
|
var english = Loc.GetArea("Jobs", CultureInfo.InvariantCulture).Keys
|
|
.Concat(new[] { "Library", "Server", "Settings", "Tooltips", "Errors" }.SelectMany(a => Loc.GetArea(a, CultureInfo.InvariantCulture).Keys))
|
|
.ToHashSet(StringComparer.Ordinal);
|
|
foreach (var key in keys) Assert.True(english.Contains(key), key);
|
|
}
|
|
}
|