1 use tinystr::{TinyStr4, TinyStr8};
2 use unic_langid_impl::parser::errors::ParserError;
3 use unic_langid_impl::parser::parse_language_identifier;
4 use unic_langid_impl::CharacterDirection;
5 use unic_langid_impl::{LanguageIdentifier, LanguageIdentifierError};
6 
assert_language_identifier( loc: &LanguageIdentifier, language: Option<&str>, script: Option<&str>, region: Option<&str>, variants: Option<&[&str]>, )7 fn assert_language_identifier(
8     loc: &LanguageIdentifier,
9     language: Option<&str>,
10     script: Option<&str>,
11     region: Option<&str>,
12     variants: Option<&[&str]>,
13 ) {
14     assert_eq!(loc.language(), language.unwrap_or("und"));
15     assert_eq!(loc.script(), script);
16     assert_eq!(loc.region(), region);
17     assert_eq!(loc.variants().collect::<Vec<_>>(), variants.unwrap_or(&[]));
18 }
19 
assert_parsed_language_identifier( input: &str, language: Option<&str>, script: Option<&str>, region: Option<&str>, variants: Option<&[&str]>, )20 fn assert_parsed_language_identifier(
21     input: &str,
22     language: Option<&str>,
23     script: Option<&str>,
24     region: Option<&str>,
25     variants: Option<&[&str]>,
26 ) {
27     let langid = parse_language_identifier(input.as_bytes()).unwrap();
28     assert_language_identifier(&langid, language, script, region, variants);
29 }
30 
31 #[test]
test_language_identifier_parser()32 fn test_language_identifier_parser() {
33     assert_parsed_language_identifier("pl", Some("pl"), None, None, None);
34     assert_parsed_language_identifier("und", None, None, None, None);
35     assert_parsed_language_identifier("en-US", Some("en"), None, Some("US"), None);
36     assert_parsed_language_identifier("en-Latn-US", Some("en"), Some("Latn"), Some("US"), None);
37     assert_parsed_language_identifier("sl-nedis", Some("sl"), None, None, Some(&["nedis"]));
38 }
39 
40 #[test]
test_language_casing()41 fn test_language_casing() {
42     assert_parsed_language_identifier("Pl", Some("pl"), None, None, None);
43     assert_parsed_language_identifier("En-uS", Some("en"), None, Some("US"), None);
44     assert_parsed_language_identifier("eN-lAtN-uS", Some("en"), Some("Latn"), Some("US"), None);
45     assert_parsed_language_identifier("ZH_cyrl_hN", Some("zh"), Some("Cyrl"), Some("HN"), None);
46 }
47 
48 #[test]
test_serialize_langid()49 fn test_serialize_langid() {
50     let langid: LanguageIdentifier = "en-Latn-US".parse().unwrap();
51     assert_eq!(&langid.to_string(), "en-Latn-US");
52 }
53 
54 #[test]
test_sorted_variants()55 fn test_sorted_variants() {
56     let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
57     assert_eq!(&langid.to_string(), "en-macos-nedis");
58 
59     let langid =
60         LanguageIdentifier::from_parts(Some("en"), None, None, &["nedis", "macos"]).unwrap();
61     assert_eq!(&langid.to_string(), "en-macos-nedis");
62 }
63 
64 #[test]
test_from_parts()65 fn test_from_parts() {
66     let langid = LanguageIdentifier::from_parts(Some("en"), None, None, &["1", "macos"]);
67     assert_eq!(
68         langid,
69         Err(LanguageIdentifierError::ParserError(
70             ParserError::InvalidSubtag
71         ))
72     );
73 }
74 
75 #[test]
test_from_parts_unchecked()76 fn test_from_parts_unchecked() {
77     let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
78     let (lang, script, region, variants) = langid.into_raw_parts();
79     let langid = LanguageIdentifier::from_raw_parts_unchecked(
80         lang.map(|l| unsafe { TinyStr8::new_unchecked(l) }),
81         script.map(|s| unsafe { TinyStr4::new_unchecked(s) }),
82         region.map(|r| unsafe { TinyStr4::new_unchecked(r) }),
83         variants.map(|v| {
84             v.into_iter()
85                 .map(|v| unsafe { TinyStr8::new_unchecked(*v) })
86                 .collect()
87         }),
88     );
89     assert_eq!(&langid.to_string(), "en-macos-nedis");
90 }
91 
92 #[test]
test_matches()93 fn test_matches() {
94     let langid_en: LanguageIdentifier = "en".parse().unwrap();
95     let langid_en_us: LanguageIdentifier = "en-US".parse().unwrap();
96     let langid_en_us2: LanguageIdentifier = "en-US".parse().unwrap();
97     let langid_pl: LanguageIdentifier = "pl".parse().unwrap();
98     assert_eq!(langid_en.matches(&langid_en_us, false, false), false);
99     assert_eq!(langid_en_us.matches(&langid_en_us2, false, false), true);
100     assert_eq!(langid_en.matches(&langid_pl, false, false), false);
101     assert_eq!(langid_en.matches(&langid_en_us, true, false), true);
102 }
103 
104 #[test]
test_set_fields()105 fn test_set_fields() {
106     let mut langid = LanguageIdentifier::default();
107     assert_eq!(&langid.to_string(), "und");
108 
109     langid.set_language("pl").expect("Setting language failed");
110     assert_eq!(&langid.to_string(), "pl");
111 
112     langid.set_language("de").expect("Setting language failed");
113     assert_eq!(&langid.to_string(), "de");
114     langid.set_region("AT").expect("Setting region failed");
115     assert_eq!(&langid.to_string(), "de-AT");
116     langid.set_script("Latn").expect("Setting script failed");
117     assert_eq!(&langid.to_string(), "de-Latn-AT");
118     langid
119         .set_variants(&["macos"])
120         .expect("Setting variants failed");
121     assert_eq!(&langid.to_string(), "de-Latn-AT-macos");
122 
123     assert_eq!(langid.has_variant("macos"), Ok(true));
124     assert_eq!(langid.has_variant("windows"), Ok(false));
125 
126     langid.clear_language();
127     assert_eq!(&langid.to_string(), "und-Latn-AT-macos");
128     langid.clear_region();
129     assert_eq!(&langid.to_string(), "und-Latn-macos");
130     langid.clear_script();
131     assert_eq!(&langid.to_string(), "und-macos");
132     langid.clear_variants();
133     assert_eq!(&langid.to_string(), "und");
134 
135     assert_eq!(langid.has_variant("macos"), Ok(false));
136 }
137 
138 #[test]
test_matches_as_range()139 fn test_matches_as_range() {
140     let langid: LanguageIdentifier = "en-US".parse().unwrap();
141     let langid2: LanguageIdentifier = "en-US-windows".parse().unwrap();
142     assert_eq!(langid.matches(&langid2, false, false), false);
143     assert_eq!(langid.matches(&langid2, true, false), true);
144     assert_eq!(langid.matches(&langid2, false, true), false);
145     assert_eq!(langid.matches(&langid2, true, true), true);
146 }
147 
148 #[test]
test_character_direction()149 fn test_character_direction() {
150     let langid: LanguageIdentifier = "en-US".parse().unwrap();
151     let langid2: LanguageIdentifier = "ar-AF".parse().unwrap();
152     assert_eq!(langid.character_direction(), CharacterDirection::LTR);
153     assert_eq!(langid2.character_direction(), CharacterDirection::RTL);
154 }
155 
156 #[test]
test_langid_ord()157 fn test_langid_ord() {
158     let input = &[
159         "en-US-macos-zarab",
160         "en-US-macos-nedis",
161         "en-US-macos",
162         "en-GB",
163         "en",
164         "en-US",
165         "ar",
166         "fr",
167         "de",
168     ];
169 
170     let mut langids = input
171         .iter()
172         .map(|l| -> LanguageIdentifier { l.parse().unwrap() })
173         .collect::<Vec<_>>();
174 
175     langids.sort();
176 
177     let result = langids.iter().map(|l| l.to_string()).collect::<Vec<_>>();
178 
179     assert_eq!(
180         &result,
181         &[
182             "ar",
183             "de",
184             "en",
185             "en-GB",
186             "en-US",
187             "en-US-macos",
188             "en-US-macos-nedis",
189             "en-US-macos-zarab",
190             "fr"
191         ]
192     );
193 }
194