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
|
// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
mod fixtures;
mod helpers;
use std::convert::TryInto;
use icu_locid::{LanguageIdentifier, Locale, ParserError};
type Result = std::result::Result<Locale, ParserError>;
fn test_langid_fixtures(tests: Vec<fixtures::LocaleTest>) {
for test in tests {
match test.output {
fixtures::LocaleInfo::String(s) => {
let input: Locale = test.input.try_into().expect("Parsing failed.");
assert_eq!(input.to_string(), s);
}
fixtures::LocaleInfo::Error(err) => {
let err: ParserError = err.into();
let input: Result = test.input.try_into();
assert_eq!(input, Err(err));
}
fixtures::LocaleInfo::Identifier(ident) => {
let input: Locale = test.input.try_into().expect("Parsing failed.");
let output: Locale = ident.clone().try_into().expect("Parsing failed.");
assert_eq!(input, output);
assert_eq!(input.to_string(), ident.identifier);
}
fixtures::LocaleInfo::Object(o) => {
let input: Locale = test.input.try_into().expect("Parsing failed.");
let output: Locale = o.try_into().expect("Parsing failed.");
assert_eq!(input, output);
}
}
}
}
#[test]
fn test_locale_parsing() {
let path = "./tests/fixtures/locale.json";
let data = helpers::read_fixture(path).expect("Failed to read a fixture");
test_langid_fixtures(data);
}
#[test]
fn test_langid_invalid() {
let path = "./tests/fixtures/invalid-extensions.json";
let data = helpers::read_fixture(path).expect("Failed to read a fixture");
test_langid_fixtures(data);
}
#[test]
fn test_locale_is_empty() {
let locale: Locale = Locale::default();
assert!(locale.extensions.is_empty());
assert_eq!(locale.to_string(), "und".to_string());
}
#[test]
fn test_locale_conversions() {
let locale: Locale = Locale::default();
let langid: LanguageIdentifier = locale.clone().into();
let locale2: Locale = langid.into();
assert_eq!(locale, locale2);
}
#[test]
fn test_locale_canonicalize() {
let locale: Locale = "En-latn-US-MacOS"
.parse()
.expect("Failed to parse a locale.");
assert_eq!(
locale.to_string(),
Locale::canonicalize("eN-latN-uS-macOS").unwrap()
);
}
#[test]
fn test_locale_normalizing_eq_str() {
let path = "./tests/fixtures/locale.json";
let tests: Vec<fixtures::LocaleTest> =
helpers::read_fixture(path).expect("Failed to read a fixture");
for test in tests {
let parsed: Locale = test.input.try_into().expect("Parsing failed.");
assert!(parsed.normalizing_eq(parsed.to_string().as_str()));
}
// Check that trailing characters are not ignored
let locale: Locale = "en".parse().expect("Parsing failed.");
assert!(!locale.normalizing_eq("en-US"));
}
#[test]
fn test_locale_strict_cmp() {
let path = "./tests/fixtures/locale.json";
let tests: Vec<fixtures::LocaleTest> =
helpers::read_fixture(path).expect("Failed to read a fixture");
let bcp47_strings = tests
.iter()
.map(|t| match t.input {
fixtures::LocaleInfo::Identifier(ref s) => s.identifier.as_str(),
_ => match t.output {
fixtures::LocaleInfo::Identifier(ref s) => s.identifier.as_str(),
_ => panic!("No string in fixture input or output: {:?}", t),
},
})
.collect::<Vec<&str>>();
for a in bcp47_strings.iter() {
for b in bcp47_strings.iter() {
let a_langid = a.parse::<Locale>().expect("Invalid BCP-47 in fixture");
let a_normalized = a_langid.to_string();
let string_cmp = a_normalized.as_bytes().cmp(b.as_bytes());
let test_cmp = a_langid.strict_cmp(b.as_bytes());
assert_eq!(string_cmp, test_cmp, "{:?}/{:?}", a, b);
}
}
}
|
