LanguageTags/LanguageTagsTests/LanguageTagParserTests.cs at main · ptr727/LanguageTags · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
namespace ptr727.LanguageTags.Tests;

public class LanguageTagParserTests : SingleInstanceFixture
{
    [Theory]
    [InlineData("en-latn-gb-boont-r-extended-sequence-x-private")]
    [InlineData("en-a-bbb-x-a-ccc")]
    [InlineData("zh-cmn-hant")]
    [InlineData("sgn-us")]
    [InlineData("en-latn")]
    [InlineData("x-all-private")]
    [InlineData("x-a-private")]
    public void Parse_Pass(string tag)
    {
        LanguageTag? languageTag = new LanguageTagParser().Parse(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(tag);
    }

    [Theory]
    [InlineData("en-gb-oed", "en-GB-oxendict")]
    [InlineData("i-navajo", "nv")]
    [InlineData("no-bok", "nb")]
    [InlineData("art-lojban", "jbo")]
    [InlineData("zh-min-nan", "nan")]
    public void Normalize_Grandfathered_Pass(string tag, string parsed)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(parsed);
    }

    [Theory]
    [InlineData("en-gb-oed", "en-GB-oxendict")]
    [InlineData("sl-afb-latn-005-nedis", "sl-afb-005-nedis")] // Suppress script
    [InlineData("ar-arb-latn-de-nedis-foobar", "arb-Latn-DE-foobar-nedis")]
    [InlineData(
        "en-latn-gb-boont-r-extended-sequence-x-private",
        "en-GB-boont-r-extended-sequence-x-private" // Suppress script
    )]
    public void Normalize_Case_Pass(string tag, string parsed)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(parsed);
    }

    [Theory]
    [InlineData("sl-afb-latn-005-nedis", "sl-afb-005-nedis")] // Suppress script
    [InlineData("ar-arb-latn-de-nedis-foobar", "arb-Latn-DE-foobar-nedis")]
    [InlineData(
        "en-latn-gb-boont-r-extended-sequence-x-private",
        "en-GB-boont-r-extended-sequence-x-private" // Suppress script
    )]
    public void Normalize_Object(string tag, string parsed)
    {
        LanguageTag? languageTag = new LanguageTagParser().Parse(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().NotBe(parsed);

        LanguageTag? normalizeTag = new LanguageTagParser().Normalize(languageTag);
        _ = normalizeTag.Should().NotBeNull();
        _ = normalizeTag.Should().NotBe(languageTag);
        _ = normalizeTag.Validate().Should().BeTrue();
        _ = normalizeTag.ToString().Should().Be(parsed);
    }

    [Theory]
    [InlineData(
        "en-latn-gb-boont-b-bbbbb-aaaaa-a-ccccc-bbbbb-x-ddddd-bbbbb",
        "en-GB-boont-a-bbbbb-ccccc-b-aaaaa-bbbbb-x-bbbbb-ddddd" // Suppress script
    )]
    public void Normalize_Sort_Pass(string tag, string parsed)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(parsed);
    }

    [Theory]
    [InlineData("")] // Empty string
    [InlineData("i")] // Too short
    [InlineData("abcdefghi")] // Too long
    [InlineData("en--gb")] // Empty tag
    [InlineData("en-€-extension")] // Non-ASCII
    [InlineData("a-extension")] // Only start with x or grandfathered
    [InlineData("en-gb-x")] // Private must have parts
    [InlineData("x")] // Private missing
    [InlineData("x-abcdefghi")] // Private too long
    [InlineData("en-gb-abcde-abcde")] // Variant repeats
    [InlineData("en-gb-a-abcd-a-abcde")] // Extension prefix repeats
    [InlineData("en-gb-a-abcd-abcd")] // Extension tag repeats
    [InlineData("en-a- ")] // Extension tag whitespace
    [InlineData("en-gb-x-abcd-x-abcd")] // Private prefix repeats
    [InlineData("en-gb-x-abcd-abcd")] // Private tag repeats
    public void Parse_Fail(string tag) => _ = new LanguageTagParser().Parse(tag).Should().BeNull();

    [Theory]
    [InlineData("iw", "he")] // Type = Language, SubTag = iw, PreferredValue = he
    [InlineData("in", "id")] // Type = Language, SubTag = in, PreferredValue = id
    public void Normalize_Language(string tag, string normalized)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(normalized);
    }

    [Theory]
    [InlineData("ar-afb", "afb")] // Extended language, SubTag = afb, Prefix = ar, PreferredValue = afb
    [InlineData("zh-yue", "yue")] // Extended language, SubTag = yue, Prefix = zh, PreferredValue = yue
    public void Normalize_Extended_Language(string tag, string normalized)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(normalized);
    }

    [Theory]
    [InlineData("zh-cmn-hant", "cmn-Hant")] // Type = Redundant, Tag = zh-cmn-Hant, PreferredValue = cmn-Hant
    [InlineData("sgn-us", "ase")] // Type = Redundant, Tag = sgn-US, PreferredValue = ase
    [InlineData("sgn-br", "bzs")] // Type = Redundant, Tag = sgn-BR, PreferredValue = bzs
    [InlineData("de-ch-1901", "de-CH-1901")] // Type = Redundant, Tag = de-CH-1901, PreferredValue = ?
    [InlineData("iu-latn", "iu-Latn")] // Type = Redundant, Tag = iu-Latn, PreferredValue = ?
    public void Normalize_Redundant(string tag, string normalized)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(normalized);
    }

    [Theory]
    [InlineData("af-latn", "af")] // Type = Language, SubTag = af, SuppressScript = Latn
    [InlineData("en-latn", "en")] // Type = Language, SubTag = en, SuppressScript = Latn
    public void Normalize_Suppress_Script(string tag, string normalized)
    {
        LanguageTag? languageTag = new LanguageTagParser().Normalize(tag);
        _ = languageTag.Should().NotBeNull();
        _ = languageTag.Validate().Should().BeTrue();
        _ = languageTag.ToString().Should().Be(normalized);
    }
}