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.
C# audio-converteravaloniabatch-conversionconvertercsharpdocument-converterdocx-to-pdfdotnetdrag-and-dropfile-conversionfile-converterheic-converterhwphwpximage-converterlinuxmacospdf-convertervideo-converterwindows
using System.Text.Json;
using System.Text.RegularExpressions;
using Filee.App.Services;
namespace Filee.App.Tests;
/// <summary>Keeps shipped languages in sync so none silently falls back to English.</summary>
public partial class LocalizationTests
{
private static string I18nDirectory
{
get
{
var dir = new DirectoryInfo(AppContext.BaseDirectory);
while (dir is not null && !File.Exists(Path.Combine(dir.FullName, "Filee.slnx")))
dir = dir.Parent;
return Path.Combine(dir!.FullName, "src", "Filee.App", "Assets", "i18n");
}
}
private static Dictionary<string, string> Load(string code) =>
JsonSerializer.Deserialize<Dictionary<string, string>>(File.ReadAllText(Path.Combine(I18nDirectory, code + ".json")))!;
public static TheoryData<string> Languages => new(LocalizationService.Languages.Where(l => l.Code != "en").Select(l => l.Code));
[Fact]
public void Shared_language_registry_covers_every_shipped_translation_once()
{
var codes = LocalizationService.Languages.Select(l => l.Code).ToList();
Assert.Equal(codes.Count, codes.Distinct(StringComparer.OrdinalIgnoreCase).Count());
Assert.Equal(Directory.GetFiles(I18nDirectory, "*.json").Select(Path.GetFileNameWithoutExtension).Order(), codes.Order());
}
[Fact]
public void Arabic_is_offered_under_its_own_name_and_reads_right_to_left()
{
Assert.Contains(("ar", "العربية"), LocalizationService.Languages);
Assert.Equal("ar", LocalizationService.Resolve("AR"));
Assert.Contains("fonts:Filee#Noto Sans Arabic", ThemeService.FontFamilies("ar"));
Assert.True(SoftPalette.IsRightToLeft("ar"));
Assert.All(LocalizationService.Languages.Where(l => l.Code != "ar"), l => Assert.False(SoftPalette.IsRightToLeft(l.Code)));
}
[Theory]
[MemberData(nameof(Languages))]
public void Catalogs_have_no_duplicate_keys_or_empty_translations(string code)
{
using var json = JsonDocument.Parse(File.ReadAllText(Path.Combine(I18nDirectory, code + ".json")));
var entries = json.RootElement.EnumerateObject().ToList();
Assert.Equal(entries.Count, entries.Select(e => e.Name).Distinct().Count());
Assert.All(entries, e => Assert.False(string.IsNullOrWhiteSpace(e.Value.GetString()), $"{code}:{e.Name}"));
}
[Fact]
public void The_flip_hint_leaves_its_arrow_to_the_donut()
{
// The hub draws the arrow itself (#554): as a character, fonts without "↻" (Linux's bundled Noto Sans) showed
// a box. The key stays first, so every language still reads "Tab back".
foreach (var code in LocalizationService.Languages.Select(l => l.Code))
{
var strings = Load(code);
foreach (var key in new[] { "donut.flip_to_back", "donut.flip_to_front" })
{
Assert.DoesNotContain("↻", strings[key]);
Assert.StartsWith("{0} ", strings[key]);
}
}
}
[Theory]
[MemberData(nameof(Languages))]
public void Every_language_has_exactly_the_english_keys(string code)
{
var english = Load("en").Keys.ToHashSet();
var other = Load(code).Keys.ToHashSet();
Assert.Empty(english.Except(other));
Assert.Empty(other.Except(english));
}
[Fact]
public void Toolbar_tabs_and_reused_categories_exist_in_every_language()
{
string[] required =
[
"toolbar.tab.all",
"toolbar.tab.media",
"toolbar.tab.edit",
"toolbar.tab.model3d_cad",
"format.category.Image",
"format.category.Document",
"format.category.Geo",
"format.category.Archive",
"format.category.Font"
];
foreach (var language in LocalizationService.Languages)
{
var translations = Load(language.Code);
foreach (var key in required)
{
Assert.True(translations.TryGetValue(key, out var value), $"{language.Code}:{key} is missing");
Assert.False(string.IsNullOrWhiteSpace(value), $"{language.Code}:{key} is empty");
}
}
}
[Theory]
[MemberData(nameof(Languages))]
public void Line_breaks_are_real_line_breaks(string code)
{
// "\\n" in the JSON is a backslash and an n on screen; English writes "\n".
foreach (var (key, value) in Load(code))
Assert.False(value.Contains("\\n"), $"{code}:{key} has a literal \\n");
}
[Theory]
[MemberData(nameof(Languages))]
public void Format_placeholders_match_english(string code)
{
var english = Load("en");
foreach (var (key, value) in Load(code))
Assert.True(
Placeholders(english[key]).SetEquals(Placeholders(value)),
$"{code}:{key} placeholders differ from English");
}
[Fact]
public void Every_key_used_in_xaml_exists()
{
var english = Load("en");
var src = Path.GetFullPath(Path.Combine(I18nDirectory, "..", ".."));
var missing = Directory.EnumerateFiles(src, "*.axaml", SearchOption.AllDirectories)
.SelectMany(f => DynamicResourceKey().Matches(File.ReadAllText(f)).Select(m => m.Groups[1].Value))
.Where(k => k.Contains('.') && !k.StartsWith("Icon.", StringComparison.Ordinal))
.Where(k => !english.ContainsKey(k))
.Distinct()
.ToList();
Assert.Empty(missing);
}
[Fact]
public void Russian_is_offered_under_its_own_name()
{
Assert.Contains(("ru", "Русский"), LocalizationService.Languages);
Assert.Equal("ru", LocalizationService.Resolve("RU"));
}
[Theory]
[InlineData("tr", "tr")]
[InlineData("tr-TR", "tr")]
[InlineData("TR-cy", "tr")]
[InlineData("tru", "en")]
[InlineData("ru-RU", "ru")]
[InlineData("en-US", "en")]
[InlineData("pl-PL", "pl")]
[InlineData("ar-EG", "ar")]
[InlineData("pt-BR", "pt-BR")]
[InlineData("pt-PT", "pt-PT")]
[InlineData("zh-CN", "zh-CN")]
[InlineData("zh-Hans-CN", "zh-CN")]
[InlineData("zh-SG", "zh-CN")]
[InlineData("zh", "zh-CN")]
[InlineData("zh-Hans-TW", "zh-CN")] // macOS: Simplified script in the Taiwan region
[InlineData("zh-TW", "zh-TW")]
[InlineData("zh-Hant-TW", "zh-TW")]
[InlineData("zh-HK", "zh-TW")]
[InlineData("zh-Hant-HK", "zh-TW")]
[InlineData("zh-MO", "zh-TW")]
[InlineData("fr-FR", "fr")]
[InlineData("fr-CA", "fr")]
[InlineData("frr-DE", "en")]
[InlineData("ne-NP", "ne")]
[InlineData("new-NP", "en")]
[InlineData("th-TH", "th")]
[InlineData("thl-NP", "en")]
[InlineData("de-DE", "de")]
[InlineData("de-AT", "de")]
[InlineData("de-CH", "de")]
[InlineData("de", "de")]
[InlineData("den-CA", "en")]
[InlineData("it-IT", "it")]
[InlineData("it-CH", "it")]
[InlineData("it", "it")]
[InlineData("itl-RU", "en")]
[InlineData("id-ID", "id")]
[InlineData("id", "id")]
[InlineData("idu-NG", "en")]
[InlineData("sv-SE", "en")]
[InlineData("", "en")] // Linux without LANG: the invariant culture
public void Auto_follows_the_language_the_user_reads_the_os_in(string os, string expected) =>
Assert.Equal(expected, LocalizationService.Resolve("auto", () => os));
[Theory]
[InlineData("ko")]
[InlineData("de")]
[InlineData("it")]
[InlineData("id")]
[InlineData("ar")]
[InlineData("ne")]
[InlineData("en")]
[InlineData("pt-PT")]
[InlineData("pt-BR")]
public void A_chosen_language_is_kept_whatever_the_os_is_in(string chosen) =>
// The OS isn't even asked: the user picked the language in Settings.
Assert.Equal(chosen, LocalizationService.Resolve(chosen, () => throw new InvalidOperationException("asked the OS")));
[Fact]
public void Auto_is_not_the_language_filee_switched_to()
{
// Filee sets the current UI culture to the language it shows; "auto" must still mean the user's own.
var before = LocalizationService.Resolve("auto");
var shown = before == "ko" ? "ja" : "ko";
var culture = System.Globalization.CultureInfo.CurrentUICulture;
try
{
System.Globalization.CultureInfo.CurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo(shown);
Assert.Equal(before, LocalizationService.Resolve("auto"));
}
finally
{
System.Globalization.CultureInfo.CurrentUICulture = culture;
}
}
[Fact]
public void Nepali_is_offered_under_its_own_name()
{
Assert.Contains(("ne", "नेपाली"), LocalizationService.Languages);
Assert.Equal("ne", LocalizationService.Resolve("NE"));
}
[Fact]
public void Turkish_is_offered_under_its_own_name()
{
Assert.Contains(("tr", "Türkçe"), LocalizationService.Languages);
Assert.Equal("tr", LocalizationService.Resolve("TR"));
}
[Fact]
public void Japanese_is_offered_under_its_own_name()
{
Assert.Contains(("ja", "日本語"), LocalizationService.Languages);
Assert.Equal("ja", LocalizationService.Resolve("JA"));
}
[Fact]
public void German_is_offered_under_its_own_name()
{
Assert.Contains(("de", "Deutsch"), LocalizationService.Languages);
Assert.Equal("de", LocalizationService.Resolve("DE"));
}
[Fact]
public void Italian_is_offered_under_its_own_name()
{
Assert.Contains(("it", "Italiano"), LocalizationService.Languages);
Assert.Equal("it", LocalizationService.Resolve("IT"));
}
[Fact]
public void Indonesian_is_offered_under_its_own_name()
{
Assert.Contains(("id", "Bahasa Indonesia"), LocalizationService.Languages);
Assert.Equal("id", LocalizationService.Resolve("ID"));
}
[Fact]
public void Portuguese_is_offered_under_its_own_name()
{
Assert.Contains(("pt-BR", "Português (Brasil)"), LocalizationService.Languages);
Assert.Equal("pt-BR", LocalizationService.Resolve("pt-BR"));
Assert.Equal("pt-BR", LocalizationService.Resolve("PT-br"));
}
[Fact]
public void French_is_offered_under_its_own_name()
{
Assert.Contains(("fr", "Français"), LocalizationService.Languages);
Assert.Equal("fr", LocalizationService.Resolve("FR"));
}
[Fact]
public void Thai_is_offered_under_its_own_name()
{
Assert.Contains(("th", "ไทย"), LocalizationService.Languages);
Assert.Equal("th", LocalizationService.Resolve("TH"));
Assert.Contains("fonts:Filee#Noto Sans Thai", ThemeService.FontFamilies("th"));
}
/// <summary>Han characters look different in Japanese, Korean and Chinese fonts: the UI language's come first.</summary>
[Theory]
[InlineData("ja", "Noto Sans JP", "Yu Gothic UI")]
[InlineData("ko", "Noto Sans KR", "Malgun Gothic")]
[InlineData("zh-CN", "Noto Sans SC", "Microsoft YaHei")]
[InlineData("en", "Noto Sans KR", "Malgun Gothic")]
public void The_ui_languages_cjk_fonts_come_first(string language, string embedded, string system)
{
var families = ThemeService.FontFamilies(language).Split(", ").Select(f => f.Replace("fonts:Filee#", "")).ToList();
string[] embeddedCjk = ["Noto Sans JP", "Noto Sans KR", "Noto Sans SC"];
string[] systemCjk = ["Yu Gothic UI", "Malgun Gothic", "Microsoft YaHei"];
Assert.Equal(embedded, families.First(embeddedCjk.Contains));
Assert.Equal(system, families.First(systemCjk.Contains));
Assert.True(embeddedCjk.Max(families.IndexOf) < systemCjk.Min(families.IndexOf), "embedded fonts before system ones");
}
[Fact]
public void Traditional_chinese_is_offered_under_its_own_name()
{
Assert.Contains(("zh-TW", "繁體中文"), LocalizationService.Languages);
Assert.Equal("zh-TW", LocalizationService.Resolve("zh-TW"));
Assert.Equal("zh-CN", LocalizationService.Resolve("zh-CN"));
}
/// <summary>The embedded Noto Sans SC has Simplified Han shapes: zh-TW lists the system Traditional fonts before it.</summary>
[Fact]
public void Traditional_chinese_takes_the_system_traditional_fonts_before_the_embedded_simplified_one()
{
var families = ThemeService.FontFamilies("zh-TW").Split(", ").Select(f => f.Replace("fonts:Filee#", "")).ToList();
Assert.True(families.IndexOf("Microsoft JhengHei UI") is >= 0 and var windows && windows < families.IndexOf("Noto Sans SC"));
Assert.True(families.IndexOf("PingFang TC") is >= 0 and var mac && mac < families.IndexOf("Noto Sans SC"));
Assert.DoesNotContain("PingFang TC", ThemeService.FontFamilies("zh-CN"));
}
private static HashSet<string> Placeholders(string text) =>
PlaceholderPattern().Matches(text).Select(m => m.Value).ToHashSet();
[GeneratedRegex(@"\{\d+\}")]
private static partial Regex PlaceholderPattern();
[GeneratedRegex(@"\{DynamicResource ([\w.]+)\}")]
private static partial Regex DynamicResourceKey();
}