diff --git a/src/Humanizer.Tests/Localisation/ru-RU/TimeSpanHumanizeTests.cs b/src/Humanizer.Tests/Localisation/ru-RU/TimeSpanHumanizeTests.cs
index 06bb2b3b6..9f7ab9860 100644
--- a/src/Humanizer.Tests/Localisation/ru-RU/TimeSpanHumanizeTests.cs
+++ b/src/Humanizer.Tests/Localisation/ru-RU/TimeSpanHumanizeTests.cs
@@ -1,142 +1,141 @@
-namespace Humanizer.Tests.Localisation.ruRU
+namespace Humanizer.Tests.Localisation.ruRU;
+
+[UseCulture("ru-RU")]
+public class TimeSpanHumanizeTests
 {
-    [UseCulture("ru-RU")]
-    public class TimeSpanHumanizeTests
-    {
-        [Theory]
-        [Trait("Translation", "Native speaker")]
-        [InlineData(366, "один год", true)]
-        [InlineData(366, "1 год")]
-        [InlineData(731, "2 года")]
-        [InlineData(1096, "3 года")]
-        [InlineData(4018, "11 лет")]
-        public void Years(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
+    [Theory]
+    [Trait("Translation", "Native speaker")]
+    [InlineData(366, "один год", true)]
+    [InlineData(366, "1 год")]
+    [InlineData(731, "2 года")]
+    [InlineData(1096, "3 года")]
+    [InlineData(4018, "11 лет")]
+    public void Years(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
 
-        [Theory]
-        [Trait("Translation", "Native speaker")]
-        [InlineData(31, "один месяц", true)]
-        [InlineData(31, "1 месяц")]
-        [InlineData(61, "2 месяца")]
-        [InlineData(92, "3 месяца")]
-        [InlineData(335, "11 месяцев")]
-        public void Months(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
+    [Theory]
+    [Trait("Translation", "Native speaker")]
+    [InlineData(31, "один месяц", true)]
+    [InlineData(31, "1 месяц")]
+    [InlineData(61, "2 месяца")]
+    [InlineData(92, "3 месяца")]
+    [InlineData(335, "11 месяцев")]
+    public void Months(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
 
-        [Theory]
-        [InlineData(7, "одна неделя", true)]
-        [InlineData(7, "1 неделя")]
-        [InlineData(14, "2 недели")]
-        [InlineData(21, "3 недели")]
-        [InlineData(28, "4 недели")]
-        [InlineData(35, "5 недель")]
-        [InlineData(77, "11 недель")]
-        public void Weeks(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(7, "одна неделя", true)]
+    [InlineData(7, "1 неделя")]
+    [InlineData(14, "2 недели")]
+    [InlineData(21, "3 недели")]
+    [InlineData(28, "4 недели")]
+    [InlineData(35, "5 недель")]
+    [InlineData(77, "11 недель")]
+    public void Weeks(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "один день", true)]
-        [InlineData(1, "1 день")]
-        [InlineData(2, "2 дня")]
-        [InlineData(3, "3 дня")]
-        [InlineData(4, "4 дня")]
-        [InlineData(5, "5 дней")]
-        [InlineData(6, "6 дней")]
-        public void Days(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "один день", true)]
+    [InlineData(1, "1 день")]
+    [InlineData(2, "2 дня")]
+    [InlineData(3, "3 дня")]
+    [InlineData(4, "4 дня")]
+    [InlineData(5, "5 дней")]
+    [InlineData(6, "6 дней")]
+    public void Days(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "один час", true)]
-        [InlineData(1, "1 час")]
-        [InlineData(2, "2 часа")]
-        [InlineData(3, "3 часа")]
-        [InlineData(4, "4 часа")]
-        [InlineData(5, "5 часов")]
-        [InlineData(6, "6 часов")]
-        [InlineData(10, "10 часов")]
-        [InlineData(11, "11 часов")]
-        [InlineData(19, "19 часов")]
-        [InlineData(20, "20 часов")]
-        [InlineData(21, "21 час")]
-        [InlineData(22, "22 часа")]
-        [InlineData(23, "23 часа")]
-        public void Hours(int hours, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "один час", true)]
+    [InlineData(1, "1 час")]
+    [InlineData(2, "2 часа")]
+    [InlineData(3, "3 часа")]
+    [InlineData(4, "4 часа")]
+    [InlineData(5, "5 часов")]
+    [InlineData(6, "6 часов")]
+    [InlineData(10, "10 часов")]
+    [InlineData(11, "11 часов")]
+    [InlineData(19, "19 часов")]
+    [InlineData(20, "20 часов")]
+    [InlineData(21, "21 час")]
+    [InlineData(22, "22 часа")]
+    [InlineData(23, "23 часа")]
+    public void Hours(int hours, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна минута", true)]
-        [InlineData(1, "1 минута")]
-        [InlineData(2, "2 минуты")]
-        [InlineData(3, "3 минуты")]
-        [InlineData(4, "4 минуты")]
-        [InlineData(5, "5 минут")]
-        [InlineData(6, "6 минут")]
-        [InlineData(10, "10 минут")]
-        [InlineData(11, "11 минут")]
-        [InlineData(19, "19 минут")]
-        [InlineData(20, "20 минут")]
-        [InlineData(21, "21 минута")]
-        [InlineData(21, "двадцать одна минута", true)]
-        [InlineData(22, "22 минуты")]
-        [InlineData(23, "23 минуты")]
-        [InlineData(24, "24 минуты")]
-        [InlineData(25, "25 минут")]
-        [InlineData(40, "40 минут")]
-        public void Minutes(int minutes, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна минута", true)]
+    [InlineData(1, "1 минута")]
+    [InlineData(2, "2 минуты")]
+    [InlineData(3, "3 минуты")]
+    [InlineData(4, "4 минуты")]
+    [InlineData(5, "5 минут")]
+    [InlineData(6, "6 минут")]
+    [InlineData(10, "10 минут")]
+    [InlineData(11, "11 минут")]
+    [InlineData(19, "19 минут")]
+    [InlineData(20, "20 минут")]
+    [InlineData(21, "21 минута")]
+    [InlineData(21, "двадцать одна минута", true)]
+    [InlineData(22, "22 минуты")]
+    [InlineData(23, "23 минуты")]
+    [InlineData(24, "24 минуты")]
+    [InlineData(25, "25 минут")]
+    [InlineData(40, "40 минут")]
+    public void Minutes(int minutes, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна секунда", true)]
-        [InlineData(1, "1 секунда")]
-        [InlineData(2, "2 секунды")]
-        [InlineData(3, "3 секунды")]
-        [InlineData(4, "4 секунды")]
-        [InlineData(5, "5 секунд")]
-        [InlineData(6, "6 секунд")]
-        [InlineData(10, "10 секунд")]
-        [InlineData(11, "11 секунд")]
-        [InlineData(19, "19 секунд")]
-        [InlineData(20, "20 секунд")]
-        [InlineData(21, "21 секунда")]
-        [InlineData(21, "двадцать одна секунда", true)]
-        [InlineData(22, "22 секунды")]
-        [InlineData(23, "23 секунды")]
-        [InlineData(24, "24 секунды")]
-        [InlineData(25, "25 секунд")]
-        [InlineData(40, "40 секунд")]
-        public void Seconds(int seconds, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна секунда", true)]
+    [InlineData(1, "1 секунда")]
+    [InlineData(2, "2 секунды")]
+    [InlineData(3, "3 секунды")]
+    [InlineData(4, "4 секунды")]
+    [InlineData(5, "5 секунд")]
+    [InlineData(6, "6 секунд")]
+    [InlineData(10, "10 секунд")]
+    [InlineData(11, "11 секунд")]
+    [InlineData(19, "19 секунд")]
+    [InlineData(20, "20 секунд")]
+    [InlineData(21, "21 секунда")]
+    [InlineData(21, "двадцать одна секунда", true)]
+    [InlineData(22, "22 секунды")]
+    [InlineData(23, "23 секунды")]
+    [InlineData(24, "24 секунды")]
+    [InlineData(25, "25 секунд")]
+    [InlineData(40, "40 секунд")]
+    public void Seconds(int seconds, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна миллисекунда", true)]
-        [InlineData(1, "1 миллисекунда")]
-        [InlineData(2, "2 миллисекунды")]
-        [InlineData(3, "3 миллисекунды")]
-        [InlineData(4, "4 миллисекунды")]
-        [InlineData(5, "5 миллисекунд")]
-        [InlineData(6, "6 миллисекунд")]
-        [InlineData(10, "10 миллисекунд")]
-        [InlineData(11, "11 миллисекунд")]
-        [InlineData(19, "19 миллисекунд")]
-        [InlineData(20, "20 миллисекунд")]
-        [InlineData(21, "21 миллисекунда")]
-        [InlineData(21, "двадцать одна миллисекунда", true)]
-        [InlineData(22, "22 миллисекунды")]
-        [InlineData(22, "двадцать две миллисекунды", true)]
-        [InlineData(23, "23 миллисекунды")]
-        [InlineData(24, "24 миллисекунды")]
-        [InlineData(25, "25 миллисекунд")]
-        [InlineData(40, "40 миллисекунд")]
-        public void Milliseconds(int milliseconds, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна миллисекунда", true)]
+    [InlineData(1, "1 миллисекунда")]
+    [InlineData(2, "2 миллисекунды")]
+    [InlineData(3, "3 миллисекунды")]
+    [InlineData(4, "4 миллисекунды")]
+    [InlineData(5, "5 миллисекунд")]
+    [InlineData(6, "6 миллисекунд")]
+    [InlineData(10, "10 миллисекунд")]
+    [InlineData(11, "11 миллисекунд")]
+    [InlineData(19, "19 миллисекунд")]
+    [InlineData(20, "20 миллисекунд")]
+    [InlineData(21, "21 миллисекунда")]
+    [InlineData(21, "двадцать одна миллисекунда", true)]
+    [InlineData(22, "22 миллисекунды")]
+    [InlineData(22, "двадцать две миллисекунды", true)]
+    [InlineData(23, "23 миллисекунды")]
+    [InlineData(24, "24 миллисекунды")]
+    [InlineData(25, "25 миллисекунд")]
+    [InlineData(40, "40 миллисекунд")]
+    public void Milliseconds(int milliseconds, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize(toWords: toWords));
 
-        [Fact]
-        public void NoTime() =>
-            Assert.Equal("0 миллисекунд", TimeSpan.Zero.Humanize());
+    [Fact]
+    public void NoTime() =>
+        Assert.Equal("0 миллисекунд", TimeSpan.Zero.Humanize());
 
-        [Fact]
-        public void NoTimeToWords() =>
-            // This one doesn't make a lot of sense but ... w/e
-            Assert.Equal("нет времени", TimeSpan.Zero.Humanize(toWords: true));
-    }
-}
+    [Fact]
+    public void NoTimeToWords() =>
+        // This one doesn't make a lot of sense but ... w/e
+        Assert.Equal("нет времени", TimeSpan.Zero.Humanize(toWords: true));
+}
\ No newline at end of file
diff --git a/src/Humanizer.Tests/Localisation/uk-UA/TimeSpanHumanizeTests.cs b/src/Humanizer.Tests/Localisation/uk-UA/TimeSpanHumanizeTests.cs
index e84dcd62b..551a0ff72 100644
--- a/src/Humanizer.Tests/Localisation/uk-UA/TimeSpanHumanizeTests.cs
+++ b/src/Humanizer.Tests/Localisation/uk-UA/TimeSpanHumanizeTests.cs
@@ -1,143 +1,142 @@
-namespace Humanizer.Tests.Localisation.ukUA
+namespace Humanizer.Tests.Localisation.ukUA;
+
+[UseCulture("uk-UA")]
+public class TimeSpanHumanizeTests
 {
-    [UseCulture("uk-UA")]
-    public class TimeSpanHumanizeTests
-    {
-        [Theory]
-        [Trait("Translation", "Google")]
-        [InlineData(366, "один рік", true)]
-        [InlineData(366, "1 рік")]
-        [InlineData(731, "2 роки")]
-        [InlineData(1096, "3 роки")]
-        [InlineData(4018, "11 років")]
-        public void Years(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
+    [Theory]
+    [Trait("Translation", "Google")]
+    [InlineData(366, "один рік", true)]
+    [InlineData(366, "1 рік")]
+    [InlineData(731, "2 роки")]
+    [InlineData(1096, "3 роки")]
+    [InlineData(4018, "11 років")]
+    public void Years(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
 
-        [Theory]
-        [Trait("Translation", "Google")]
-        [InlineData(31, "один місяць", true)]
-        [InlineData(31, "1 місяць")]
-        [InlineData(61, "2 місяці")]
-        [InlineData(92, "3 місяці")]
-        [InlineData(335, "11 місяців")]
-        public void Months(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
+    [Theory]
+    [Trait("Translation", "Google")]
+    [InlineData(31, "один місяць", true)]
+    [InlineData(31, "1 місяць")]
+    [InlineData(61, "2 місяці")]
+    [InlineData(92, "3 місяці")]
+    [InlineData(335, "11 місяців")]
+    public void Months(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(maxUnit: TimeUnit.Year, toWords: toWords));
 
-        [Theory]
-        [InlineData(7, "один тиждень", true)]
-        [InlineData(7, "1 тиждень")]
-        [InlineData(14, "2 тижні")]
-        [InlineData(21, "3 тижні")]
-        [InlineData(28, "4 тижні")]
-        [InlineData(35, "5 тижнів")]
-        [InlineData(77, "11 тижнів")]
-        [InlineData(147, "двадцять один тиждень", true)]
-        public void Weeks(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(7, "один тиждень", true)]
+    [InlineData(7, "1 тиждень")]
+    [InlineData(14, "2 тижні")]
+    [InlineData(21, "3 тижні")]
+    [InlineData(28, "4 тижні")]
+    [InlineData(35, "5 тижнів")]
+    [InlineData(77, "11 тижнів")]
+    [InlineData(147, "двадцять один тиждень", true)]
+    public void Weeks(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "один день", true)]
-        [InlineData(1, "1 день")]
-        [InlineData(2, "2 дні")]
-        [InlineData(3, "3 дні")]
-        [InlineData(4, "4 дні")]
-        [InlineData(5, "5 днів")]
-        [InlineData(6, "6 днів")]
-        [InlineData(21, "двадцять один день", true)]
-        public void Days(int days, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords, maxUnit: TimeUnit.Day));
+    [Theory]
+    [InlineData(1, "один день", true)]
+    [InlineData(1, "1 день")]
+    [InlineData(2, "2 дні")]
+    [InlineData(3, "3 дні")]
+    [InlineData(4, "4 дні")]
+    [InlineData(5, "5 днів")]
+    [InlineData(6, "6 днів")]
+    [InlineData(21, "двадцять один день", true)]
+    public void Days(int days, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromDays(days).Humanize(toWords: toWords, maxUnit: TimeUnit.Day));
 
-        [Theory]
-        [InlineData(1, "одна година", true)]
-        [InlineData(1, "1 година")]
-        [InlineData(2, "2 години")]
-        [InlineData(3, "3 години")]
-        [InlineData(4, "4 години")]
-        [InlineData(5, "5 годин")]
-        [InlineData(6, "6 годин")]
-        [InlineData(10, "10 годин")]
-        [InlineData(11, "11 годин")]
-        [InlineData(19, "19 годин")]
-        [InlineData(20, "20 годин")]
-        [InlineData(21, "21 година")]
-        [InlineData(21, "двадцять одна година", true)]
-        [InlineData(22, "22 години")]
-        [InlineData(23, "23 години")]
-        public void Hours(int hours, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна година", true)]
+    [InlineData(1, "1 година")]
+    [InlineData(2, "2 години")]
+    [InlineData(3, "3 години")]
+    [InlineData(4, "4 години")]
+    [InlineData(5, "5 годин")]
+    [InlineData(6, "6 годин")]
+    [InlineData(10, "10 годин")]
+    [InlineData(11, "11 годин")]
+    [InlineData(19, "19 годин")]
+    [InlineData(20, "20 годин")]
+    [InlineData(21, "21 година")]
+    [InlineData(21, "двадцять одна година", true)]
+    [InlineData(22, "22 години")]
+    [InlineData(23, "23 години")]
+    public void Hours(int hours, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromHours(hours).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна хвилина",true)]
-        [InlineData(1, "1 хвилина")]
-        [InlineData(2, "2 хвилини")]
-        [InlineData(3, "3 хвилини")]
-        [InlineData(4, "4 хвилини")]
-        [InlineData(5, "5 хвилин")]
-        [InlineData(6, "6 хвилин")]
-        [InlineData(10, "10 хвилин")]
-        [InlineData(11, "11 хвилин")]
-        [InlineData(19, "19 хвилин")]
-        [InlineData(20, "20 хвилин")]
-        [InlineData(21, "21 хвилина")]
-        [InlineData(21, "двадцять одна хвилина", true)]
-        [InlineData(22, "22 хвилини")]
-        [InlineData(23, "23 хвилини")]
-        [InlineData(24, "24 хвилини")]
-        [InlineData(25, "25 хвилин")]
-        [InlineData(40, "40 хвилин")]
-        public void Minutes(int minutes, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна хвилина",true)]
+    [InlineData(1, "1 хвилина")]
+    [InlineData(2, "2 хвилини")]
+    [InlineData(3, "3 хвилини")]
+    [InlineData(4, "4 хвилини")]
+    [InlineData(5, "5 хвилин")]
+    [InlineData(6, "6 хвилин")]
+    [InlineData(10, "10 хвилин")]
+    [InlineData(11, "11 хвилин")]
+    [InlineData(19, "19 хвилин")]
+    [InlineData(20, "20 хвилин")]
+    [InlineData(21, "21 хвилина")]
+    [InlineData(21, "двадцять одна хвилина", true)]
+    [InlineData(22, "22 хвилини")]
+    [InlineData(23, "23 хвилини")]
+    [InlineData(24, "24 хвилини")]
+    [InlineData(25, "25 хвилин")]
+    [InlineData(40, "40 хвилин")]
+    public void Minutes(int minutes, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromMinutes(minutes).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна секунда", true)]
-        [InlineData(1, "1 секунда")]
-        [InlineData(2, "2 секунди")]
-        [InlineData(3, "3 секунди")]
-        [InlineData(4, "4 секунди")]
-        [InlineData(5, "5 секунд")]
-        [InlineData(6, "6 секунд")]
-        [InlineData(10, "10 секунд")]
-        [InlineData(11, "11 секунд")]
-        [InlineData(19, "19 секунд")]
-        [InlineData(20, "20 секунд")]
-        [InlineData(21, "21 секунда")]
-        [InlineData(21, "двадцять одна секунда", true)]
-        [InlineData(22, "22 секунди")]
-        [InlineData(23, "23 секунди")]
-        [InlineData(24, "24 секунди")]
-        [InlineData(25, "25 секунд")]
-        [InlineData(40, "40 секунд")]
-        public void Seconds(int seconds, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна секунда", true)]
+    [InlineData(1, "1 секунда")]
+    [InlineData(2, "2 секунди")]
+    [InlineData(3, "3 секунди")]
+    [InlineData(4, "4 секунди")]
+    [InlineData(5, "5 секунд")]
+    [InlineData(6, "6 секунд")]
+    [InlineData(10, "10 секунд")]
+    [InlineData(11, "11 секунд")]
+    [InlineData(19, "19 секунд")]
+    [InlineData(20, "20 секунд")]
+    [InlineData(21, "21 секунда")]
+    [InlineData(21, "двадцять одна секунда", true)]
+    [InlineData(22, "22 секунди")]
+    [InlineData(23, "23 секунди")]
+    [InlineData(24, "24 секунди")]
+    [InlineData(25, "25 секунд")]
+    [InlineData(40, "40 секунд")]
+    public void Seconds(int seconds, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromSeconds(seconds).Humanize(toWords: toWords));
 
-        [Theory]
-        [InlineData(1, "одна мілісекунда", true)]
-        [InlineData(1, "1 мілісекунда")]
-        [InlineData(2, "2 мілісекунди")]
-        [InlineData(3, "3 мілісекунди")]
-        [InlineData(4, "4 мілісекунди")]
-        [InlineData(5, "5 мілісекунд")]
-        [InlineData(6, "6 мілісекунд")]
-        [InlineData(10, "10 мілісекунд")]
-        [InlineData(11, "11 мілісекунд")]
-        [InlineData(19, "19 мілісекунд")]
-        [InlineData(20, "20 мілісекунд")]
-        [InlineData(21, "21 мілісекунда")]
-        [InlineData(21, "двадцять одна мілісекунда", true)]
-        [InlineData(22, "22 мілісекунди")]
-        [InlineData(23, "23 мілісекунди")]
-        [InlineData(24, "24 мілісекунди")]
-        [InlineData(25, "25 мілісекунд")]
-        [InlineData(40, "40 мілісекунд")]
-        public void Milliseconds(int milliseconds, string expected, bool toWords = false) =>
-            Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize(toWords: toWords));
+    [Theory]
+    [InlineData(1, "одна мілісекунда", true)]
+    [InlineData(1, "1 мілісекунда")]
+    [InlineData(2, "2 мілісекунди")]
+    [InlineData(3, "3 мілісекунди")]
+    [InlineData(4, "4 мілісекунди")]
+    [InlineData(5, "5 мілісекунд")]
+    [InlineData(6, "6 мілісекунд")]
+    [InlineData(10, "10 мілісекунд")]
+    [InlineData(11, "11 мілісекунд")]
+    [InlineData(19, "19 мілісекунд")]
+    [InlineData(20, "20 мілісекунд")]
+    [InlineData(21, "21 мілісекунда")]
+    [InlineData(21, "двадцять одна мілісекунда", true)]
+    [InlineData(22, "22 мілісекунди")]
+    [InlineData(23, "23 мілісекунди")]
+    [InlineData(24, "24 мілісекунди")]
+    [InlineData(25, "25 мілісекунд")]
+    [InlineData(40, "40 мілісекунд")]
+    public void Milliseconds(int milliseconds, string expected, bool toWords = false) =>
+        Assert.Equal(expected, TimeSpan.FromMilliseconds(milliseconds).Humanize(toWords: toWords));
 
-        [Fact]
-        public void NoTime() =>
-            Assert.Equal("0 мілісекунд", TimeSpan.Zero.Humanize());
+    [Fact]
+    public void NoTime() =>
+        Assert.Equal("0 мілісекунд", TimeSpan.Zero.Humanize());
 
-        [Fact]
-        public void NoTimeToWords() =>
-            Assert.Equal("без часу", TimeSpan.Zero.Humanize(toWords: true));
-    }
-}
+    [Fact]
+    public void NoTimeToWords() =>
+        Assert.Equal("без часу", TimeSpan.Zero.Humanize(toWords: true));
+}
\ No newline at end of file
diff --git a/src/Humanizer.Tests/Localisation/vi/NumberToWordsTests.cs b/src/Humanizer.Tests/Localisation/vi/NumberToWordsTests.cs
index e2924173f..bb4d4bef6 100644
--- a/src/Humanizer.Tests/Localisation/vi/NumberToWordsTests.cs
+++ b/src/Humanizer.Tests/Localisation/vi/NumberToWordsTests.cs
@@ -1,72 +1,71 @@
-namespace Humanizer.Tests.Localisation.vi
+namespace Humanizer.Tests.Localisation.vi;
+
+[UseCulture("vi")]
+public class NumberToWordsTests
 {
-    [UseCulture("vi")]
-    public class NumberToWordsTests
-    {
-        [Theory]
-        [InlineData(0, "không")]
-        [InlineData(1, "một")]
-        [InlineData(2, "hai")]
-        [InlineData(3, "ba")]
-        [InlineData(4, "bốn")]
-        [InlineData(5, "năm")]
-        [InlineData(6, "sáu")]
-        [InlineData(7, "bảy")]
-        [InlineData(8, "tám")]
-        [InlineData(9, "chín")]
-        [InlineData(10, "mười")]
-        [InlineData(11, "mười một")]
-        [InlineData(14, "mười bốn")]
-        [InlineData(15, "mười lăm")]
-        [InlineData(21, "hai mươi mốt")]
-        [InlineData(24, "hai mươi tư")]
-        [InlineData(25, "hai mươi lăm")]
-        [InlineData(50, "năm mươi")]
-        [InlineData(55, "năm mươi lăm")]
-        [InlineData(100, "một trăm")]
-        [InlineData(105, "một trăm linh năm")]
-        [InlineData(110, "một trăm mười")]
-        [InlineData(114, "một trăm mười bốn")]
-        [InlineData(115, "một trăm mười lăm")]
-        [InlineData(134, "một trăm ba mươi tư")]
-        [InlineData(500, "năm trăm")]
-        [InlineData(505, "năm trăm linh năm")]
-        [InlineData(555, "năm trăm năm mươi lăm")]
-        [InlineData(1000, "một nghìn")]
-        [InlineData(1005, "một nghìn linh năm")]
-        [InlineData(1115, "một nghìn một trăm mười lăm")]
-        [InlineData(10005, "mười nghìn linh năm")]
-        [InlineData(10115, "mười nghìn một trăm mười lăm")]
-        [InlineData(11115, "mười một nghìn một trăm mười lăm")]
-        [InlineData(30005, "ba mươi nghìn linh năm")]
-        [InlineData(100005, "một trăm nghìn linh năm")]
-        [InlineData(1000000, "một triệu")]
-        [InlineData(100001005, "một trăm triệu một nghìn linh năm")]
-        [InlineData(1000000000, "một tỉ")]
-        [InlineData(1111111111111111, "một triệu một trăm mười một nghìn một trăm mười một tỉ một trăm mười một triệu một trăm mười một nghìn một trăm mười một")]
-        [InlineData(5101101101101151101, "năm tỉ một trăm linh một triệu một trăm linh một nghìn một trăm linh một tỉ một trăm linh một triệu một trăm năm mươi mốt nghìn một trăm linh một")]
-        public void ToWords(long number, string expected) =>
-            Assert.Equal(expected, number.ToWords());
+    [Theory]
+    [InlineData(0, "không")]
+    [InlineData(1, "một")]
+    [InlineData(2, "hai")]
+    [InlineData(3, "ba")]
+    [InlineData(4, "bốn")]
+    [InlineData(5, "năm")]
+    [InlineData(6, "sáu")]
+    [InlineData(7, "bảy")]
+    [InlineData(8, "tám")]
+    [InlineData(9, "chín")]
+    [InlineData(10, "mười")]
+    [InlineData(11, "mười một")]
+    [InlineData(14, "mười bốn")]
+    [InlineData(15, "mười lăm")]
+    [InlineData(21, "hai mươi mốt")]
+    [InlineData(24, "hai mươi tư")]
+    [InlineData(25, "hai mươi lăm")]
+    [InlineData(50, "năm mươi")]
+    [InlineData(55, "năm mươi lăm")]
+    [InlineData(100, "một trăm")]
+    [InlineData(105, "một trăm linh năm")]
+    [InlineData(110, "một trăm mười")]
+    [InlineData(114, "một trăm mười bốn")]
+    [InlineData(115, "một trăm mười lăm")]
+    [InlineData(134, "một trăm ba mươi tư")]
+    [InlineData(500, "năm trăm")]
+    [InlineData(505, "năm trăm linh năm")]
+    [InlineData(555, "năm trăm năm mươi lăm")]
+    [InlineData(1000, "một nghìn")]
+    [InlineData(1005, "một nghìn linh năm")]
+    [InlineData(1115, "một nghìn một trăm mười lăm")]
+    [InlineData(10005, "mười nghìn linh năm")]
+    [InlineData(10115, "mười nghìn một trăm mười lăm")]
+    [InlineData(11115, "mười một nghìn một trăm mười lăm")]
+    [InlineData(30005, "ba mươi nghìn linh năm")]
+    [InlineData(100005, "một trăm nghìn linh năm")]
+    [InlineData(1000000, "một triệu")]
+    [InlineData(100001005, "một trăm triệu một nghìn linh năm")]
+    [InlineData(1000000000, "một tỉ")]
+    [InlineData(1111111111111111, "một triệu một trăm mười một nghìn một trăm mười một tỉ một trăm mười một triệu một trăm mười một nghìn một trăm mười một")]
+    [InlineData(5101101101101151101, "năm tỉ một trăm linh một triệu một trăm linh một nghìn một trăm linh một tỉ một trăm linh một triệu một trăm năm mươi mốt nghìn một trăm linh một")]
+    public void ToWords(long number, string expected) =>
+        Assert.Equal(expected, number.ToWords());
 
-        [Theory]
-        [InlineData(0, "thứ không")]
-        [InlineData(1, "thứ nhất")]
-        [InlineData(2, "thứ nhì")]
-        [InlineData(3, "thứ ba")]
-        [InlineData(4, "thứ tư")]
-        [InlineData(5, "thứ năm")]
-        [InlineData(6, "thứ sáu")]
-        [InlineData(7, "thứ bảy")]
-        [InlineData(8, "thứ tám")]
-        [InlineData(9, "thứ chín")]
-        [InlineData(10, "thứ mười")]
-        [InlineData(11, "thứ mười một")]
-        [InlineData(14, "thứ mười bốn")]
-        [InlineData(15, "thứ mười lăm")]
-        [InlineData(21, "thứ hai mươi mốt")]
-        [InlineData(24, "thứ hai mươi tư")]
-        [InlineData(25, "thứ hai mươi lăm")]
-        public void ToOrdinalWords(int number, string expected) =>
-            Assert.Equal(expected, number.ToOrdinalWords());
-    }
-}
+    [Theory]
+    [InlineData(0, "thứ không")]
+    [InlineData(1, "thứ nhất")]
+    [InlineData(2, "thứ nhì")]
+    [InlineData(3, "thứ ba")]
+    [InlineData(4, "thứ tư")]
+    [InlineData(5, "thứ năm")]
+    [InlineData(6, "thứ sáu")]
+    [InlineData(7, "thứ bảy")]
+    [InlineData(8, "thứ tám")]
+    [InlineData(9, "thứ chín")]
+    [InlineData(10, "thứ mười")]
+    [InlineData(11, "thứ mười một")]
+    [InlineData(14, "thứ mười bốn")]
+    [InlineData(15, "thứ mười lăm")]
+    [InlineData(21, "thứ hai mươi mốt")]
+    [InlineData(24, "thứ hai mươi tư")]
+    [InlineData(25, "thứ hai mươi lăm")]
+    public void ToOrdinalWords(int number, string expected) =>
+        Assert.Equal(expected, number.ToOrdinalWords());
+}
\ No newline at end of file