Debian Codegraph @

third_party/rust/unic-langid-impl/tests/language_identifier_test.rs

raw
1 use unic_langid_impl::parser::parse_language_identifier;
2 use unic_langid_impl::subtags;
3 use unic_langid_impl::CharacterDirection;
4 use unic_langid_impl::LanguageIdentifier;
5
6 fn assert_language_identifier(
7 loc: &LanguageIdentifier,
8 language: Option<&str>,
9 script: Option<&str>,
10 region: Option<&str>,
11 variants: Option<&[&str]>,
12 ) {
13 assert_eq!(
14 loc.language,
15 language.map_or(subtags::Language::default(), |l| {
16 subtags::Language::from_bytes(l.as_bytes()).unwrap()
17 })
18 );
19 assert_eq!(loc.script, script.map(|s| s.parse().unwrap()));
20 assert_eq!(loc.region, region.map(|r| r.parse().unwrap()));
21 let v = variants
22 .unwrap_or(&[])
23 .iter()
24 .map(|v| -> subtags::Variant { v.parse().unwrap() })
25 .collect::<Vec<_>>();
26 assert_eq!(
27 loc.variants().collect::<Vec<_>>(),
28 v.iter().collect::<Vec<_>>(),
29 );
30 }
31
32 fn assert_parsed_language_identifier(
33 input: &str,
34 language: Option<&str>,
35 script: Option<&str>,
36 region: Option<&str>,
37 variants: Option<&[&str]>,
38 ) {
39 let langid = parse_language_identifier(input.as_bytes()).unwrap();
40 assert_language_identifier(&langid, language, script, region, variants);
41 }
42
43 #[test]
44 fn test_language_identifier_parser() {
45 assert_parsed_language_identifier("pl", Some("pl"), None, None, None);
46 assert_parsed_language_identifier("und", None, None, None, None);
47 assert_parsed_language_identifier("en-US", Some("en"), None, Some("US"), None);
48 assert_parsed_language_identifier("en-Latn-US", Some("en"), Some("Latn"), Some("US"), None);
49 assert_parsed_language_identifier("sl-nedis", Some("sl"), None, None, Some(&["nedis"]));
50 }
51
52 #[test]
53 fn test_language_casing() {
54 assert_parsed_language_identifier("Pl", Some("pl"), None, None, None);
55 assert_parsed_language_identifier("En-uS", Some("en"), None, Some("US"), None);
56 assert_parsed_language_identifier("eN-lAtN-uS", Some("en"), Some("Latn"), Some("US"), None);
57 assert_parsed_language_identifier("ZH_cyrl_hN", Some("zh"), Some("Cyrl"), Some("HN"), None);
58 }
59
60 #[test]
61 fn test_serialize_langid() {
62 let langid: LanguageIdentifier = "en-Latn-US".parse().unwrap();
63 assert_eq!(&langid.to_string(), "en-Latn-US");
64 }
65
66 #[test]
67 fn test_sorted_variants() {
68 let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
69 assert_eq!(&langid.to_string(), "en-macos-nedis");
70
71 let langid = LanguageIdentifier::from_parts(
72 "en".parse().unwrap(),
73 None,
74 None,
75 &["nedis".parse().unwrap(), "macos".parse().unwrap()],
76 );
77 assert_eq!(&langid.to_string(), "en-macos-nedis");
78 }
79
80 #[test]
81 fn test_from_parts_unchecked() {
82 let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
83 let (lang, script, region, variants) = langid.into_parts();
84 let langid = LanguageIdentifier::from_raw_parts_unchecked(
85 lang,
86 script,
87 region,
88 Some(variants.into_boxed_slice()),
89 );
90 assert_eq!(&langid.to_string(), "en-macos-nedis");
91 }
92
93 #[test]
94 fn test_matches() {
95 let langid_en: LanguageIdentifier = "en".parse().unwrap();
96 let langid_en_us: LanguageIdentifier = "en-US".parse().unwrap();
97 let langid_en_us2: LanguageIdentifier = "en-US".parse().unwrap();
98 let langid_pl: LanguageIdentifier = "pl".parse().unwrap();
99 assert_eq!(langid_en.matches(&langid_en_us, false, false), false);
100 assert_eq!(langid_en_us.matches(&langid_en_us2, false, false), true);
101 assert_eq!(langid_en.matches(&langid_pl, false, false), false);
102 assert_eq!(langid_en.matches(&langid_en_us, true, false), true);
103 }
104
105 #[test]
106 fn test_set_fields() {
107 let mut langid = LanguageIdentifier::default();
108 assert_eq!(&langid.to_string(), "und");
109
110 langid.language = "pl".parse().expect("Setting language failed");
111 assert_eq!(&langid.to_string(), "pl");
112
113 langid.language = "de".parse().expect("Setting language failed");
114 assert_eq!(&langid.to_string(), "de");
115 langid.region = Some("AT".parse().expect("Setting region failed"));
116 assert_eq!(&langid.to_string(), "de-AT");
117 langid.script = Some("Latn".parse().expect("Setting script failed"));
118 assert_eq!(&langid.to_string(), "de-Latn-AT");
119 langid.set_variants(&["macos".parse().expect("Setting variants failed")]);
120 assert_eq!(&langid.to_string(), "de-Latn-AT-macos");
121
122 assert_eq!(langid.has_variant("macos".parse().unwrap()), true);
123 assert_eq!(langid.has_variant("windows".parse().unwrap()), false);
124
125 langid.language.clear();
126 assert_eq!(&langid.to_string(), "und-Latn-AT-macos");
127 langid.region = None;
128 assert_eq!(&langid.to_string(), "und-Latn-macos");
129 langid.script = None;
130 assert_eq!(&langid.to_string(), "und-macos");
131 langid.clear_variants();
132 assert_eq!(&langid.to_string(), "und");
133
134 assert_eq!(langid.has_variant("macos".parse().unwrap()), false);
135 }
136
137 #[test]
138 fn test_matches_as_range() {
139 let langid: LanguageIdentifier = "en-US".parse().unwrap();
140 let langid2: LanguageIdentifier = "en-US-windows".parse().unwrap();
141 assert_eq!(langid.matches(&langid2, false, false), false);
142 assert_eq!(langid.matches(&langid2, true, false), true);
143 assert_eq!(langid.matches(&langid2, false, true), false);
144 assert_eq!(langid.matches(&langid2, true, true), true);
145 }
146
147 #[test]
148 fn test_character_direction() {
149 let en_us: LanguageIdentifier = "en-US".parse().unwrap();
150 assert_eq!(en_us.character_direction(), CharacterDirection::LTR);
151
152 let ar_af: LanguageIdentifier = "ar-AF".parse().unwrap();
153 assert_eq!(ar_af.character_direction(), CharacterDirection::RTL);
154
155 let ks: LanguageIdentifier = "ks".parse().unwrap();
156 assert_eq!(ks.character_direction(), CharacterDirection::RTL);
157
158 let ks_deva: LanguageIdentifier = "ks-Deva".parse().unwrap();
159 assert_eq!(ks_deva.character_direction(), CharacterDirection::LTR);
160
161 let mn_mong: LanguageIdentifier = "mn-Mong".parse().unwrap();
162 assert_eq!(mn_mong.character_direction(), CharacterDirection::TTB);
163
164 let lid: LanguageIdentifier = "pa-Guru".parse().unwrap();
165 assert_eq!(lid.character_direction(), CharacterDirection::LTR);
166
167 let lid_pa_pk: LanguageIdentifier = "pa-PK".parse().unwrap();
168 assert_eq!(lid_pa_pk.character_direction(), CharacterDirection::RTL);
169
170 let lid_ar_us: LanguageIdentifier = "ar-US".parse().unwrap();
171 assert_eq!(lid_ar_us.character_direction(), CharacterDirection::RTL);
172 }
173
174 #[cfg(not(feature = "likelysubtags"))]
175 #[test]
176 fn test_character_direction_without_likelysubtags() {
177 let lid: LanguageIdentifier = "pa".parse().unwrap();
178 assert_eq!(lid.character_direction(), CharacterDirection::RTL);
179 }
180
181 #[cfg(feature = "likelysubtags")]
182 #[test]
183 fn test_character_direction_with_likelysubtags() {
184 let lid_pa: LanguageIdentifier = "pa".parse().unwrap();
185 assert_eq!(lid_pa.character_direction(), CharacterDirection::LTR);
186 }
187
188 #[test]
189 fn test_langid_ord() {
190 let input = &[
191 "en-US-macos-zarab",
192 "en-US-macos-nedis",
193 "en-US-macos",
194 "en-GB",
195 "en",
196 "en-US",
197 "ar",
198 "fr",
199 "de",
200 ];
201
202 let mut langids = input
203 .iter()
204 .map(|l| -> LanguageIdentifier { l.parse().unwrap() })
205 .collect::<Vec<_>>();
206
207 langids.sort();
208
209 let result = langids.iter().map(|l| l.to_string()).collect::<Vec<_>>();
210
211 assert_eq!(
212 &result,
213 &[
214 "ar",
215 "de",
216 "en",
217 "en-GB",
218 "en-US",
219 "en-US-macos",
220 "en-US-macos-nedis",
221 "en-US-macos-zarab",
222 "fr"
223 ]
224 );
225 }