| 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 |
} |