Pin the test run to the invariant culture

Seven tests asserted English text and a decimal point and failed on a French Windows ("1,5 KB" instead of "1.5 KB", "Langue" instead of "Language"). The app formats for the user's culture on purpose, so the tests are what needed fixing:
SpaceSharp.Tests/TestCulture.cs sets the default thread culture to invariant
when the test assembly loads, before xUnit starts its workers, so the suite
runs the same on every machine. A new test switches to fr-FR and asserts the French output, so that behavior is expected rather than tolerated. Tests that need another culture keep setting it on their own thread and restoring it.

Author: ClearanceClarence

CHANGELOG.md

@@ -7,6 +7,7 @@ What changed in each SpaceSharp release from 2.0 on, newest first; the 1.x relea
 No visible change: a readability pass over the whole code base.
 
 ### Under the hood
+- The tests no longer depend on the developer's Windows language: the test assembly pins the invariant culture, so a French Windows no longer fails seven tests on `1,5 KB` and `Langue`. A new test asserts the French output on purpose. Reported by a SpaceMonger veteran trying SpaceSharp on a French PC.
 - Every C# file was reworked for readability without changing what it does: descriptive names in place of one-letter variables and lambda parameters, long methods split into focused ones (the MFT scanner, the Settings tabs, the Insights and Changes views, the scan card), nested blocks flattened with early returns, long expressions and argument lists broken up, and a comment on every intentionally ignored exception saying why it is safe to ignore. Public members, settings, file formats and localized strings are untouched.
 - The XML documentation now covers the whole solution: every documented method and constructor has a `<param>` for each parameter, in declaration order, with the unit, range, null meaning or callback contract rather than a restated name, plus `<returns>` and `<typeparam>` where they apply; public members and the non-trivial private ones that had no summary have one. The code itself is unchanged.
 - `CODING_STANDARDS.md` writes those rules down, with examples from the code of what to do and what not to do; CONTRIBUTING and DEVELOPING link to it.

SpaceSharp.Tests/LocalizationTests.cs

@@ -1,6 +1,7 @@
 using System.Globalization;
 using System.Text.RegularExpressions;
 using System.Xml.Linq;
+using SpaceSharp.Services;
 using SpaceSharp.Util;
 
 namespace SpaceSharp.Tests;
@@ -143,4 +144,21 @@ public void FormatUsesTheCurrentCultureForNumbers()
         }
         finally { (CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture) = before; }
     }
+
+    /// <summary>Sizes, percentages and resources follow the user's culture: a French Windows sees a decimal comma and French text.</summary>
+    /// <remarks>The rest of the suite runs under the invariant culture (see <see cref="TestCulture"/>); this is the one test that asserts the other way.</remarks>
+    [Fact]
+    public void FrenchCultureFormatsWithADecimalComma()
+    {
+        (CultureInfo CurrentCulture, CultureInfo CurrentUICulture) before = (CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture);
+        try
+        {
+            CultureInfo.CurrentCulture = CultureInfo.CurrentUICulture = CultureInfo.GetCultureInfo("fr-FR");
+            Assert.Equal("1,5 KB", SizeFormatter.Format(1536));
+            Assert.Equal("1,07 KB", SizeFormatter.Compact(1100));
+            Assert.Equal("8,9%", InspectSummary.Percent(0.089));
+            Assert.Equal("Langue", Strings.Get("Settings_Language"));
+        }
+        finally { (CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture) = before; }
+    }
 }

SpaceSharp.Tests/TestCulture.cs

@@ -0,0 +1,24 @@
+using System.Globalization;
+using System.Runtime.CompilerServices;
+
+namespace SpaceSharp.Tests;
+
+/// <summary>Pins the test run to the invariant culture so expected strings do not depend on the developer's Windows settings.</summary>
+/// <remarks>
+/// The app formats sizes, percentages and dates for the user's culture on purpose, and the resources fall back to English
+/// under the invariant culture. Without this, a French Windows turns "1.5 KB" into "1,5 KB" and "Language" into "Langue"
+/// and seven tests fail. A test that needs a specific culture sets it on its own thread and restores it in a finally block,
+/// as <see cref="LocalizationTests"/> does; the thread setting wins over the default set here.
+/// </remarks>
+public static class TestCulture
+{
+    /// <summary>Runs once when the test assembly loads, before xUnit creates its worker threads.</summary>
+    [ModuleInitializer]
+    public static void Pin()
+    {
+        CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
+        CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+        CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
+    }
+}