use core::str::FromStr;
use smol_bytes::Utf8Bytes;
use super::{LanguageId, ParseLanguageIdError};
use crate::primitives::lang::{
Language, ParseLanguageError, ParseRegionError, Region, ScriptSubtag, registry,
};
fn door(sent: &str) -> Result<LanguageId, ParseLanguageIdError> {
LanguageId::new(sent)
}
fn admitted(sent: &str) -> LanguageId {
door(sent).unwrap_or_else(|refused| panic!("`{sent}` is a language tag: {refused}"))
}
fn canonical(sent: &str) -> String {
admitted(sent).to_string()
}
#[test]
fn the_door_applies_every_composition_rule_the_ruling_names() {
for (sent, held, why) in [
("zh_Hans_CN", "zh-Hans-CN", "underscores"),
("en_US", "en-US", "underscores"),
("en-Latn", "en", "`en` implies `Latn`"),
("en-Latn-US", "en-US", "and the region survives it"),
("fr-latn", "fr", "any case"),
("he-Hebr", "he", "not only Latin"),
("zh-Hans", "zh-Hans", "`zh` implies nothing"),
("zh-Hant", "zh-Hant", "and the two stay apart"),
("zh-Hant-TW", "zh-Hant-TW", "with a region beside it"),
("i-klingon", "tlh", "grandfathered"),
("I-KLINGON", "tlh", "grandfathered, any case"),
("zh-guoyu", "cmn", "grandfathered"),
("art-lojban", "jbo", "grandfathered"),
("no-bok", "nb", "grandfathered"),
(
"en-GB-oed",
"en-GB-oxendict",
"a multi-subtag preferred value",
),
(
"GER-latn-de",
"de-DE",
"alpha-3, suppression and region case, at once",
),
("deu-DE", "de-DE", "an mp4's language subtag"),
("iw-IL", "he-IL", "a deprecated language"),
("de-BU", "de-MM", "a deprecated region"),
("EN-us", "en-US", "case on two seats"),
] {
assert_eq!(canonical(sent), held, "`{sent}` — {why}");
}
}
#[test]
fn each_seat_is_filled_by_the_shape_that_belongs_in_it() {
let full = admitted("sr-Cyrl-RS");
assert_eq!(full.language().as_str(), "sr");
assert_eq!(full.script().map(ScriptSubtag::as_str), Some("Cyrl"));
assert_eq!(full.region().map(Region::as_str), Some("RS"));
assert_eq!(full.rest(), None);
let bare = admitted("de");
assert_eq!(bare.language().as_str(), "de");
assert_eq!(bare.script(), None);
assert_eq!(bare.region(), None);
let regional = admitted("de-AT");
assert_eq!(regional.script(), None);
assert_eq!(regional.region().map(Region::as_str), Some("AT"));
let area = admitted("es-419");
assert_eq!(area.region().map(Region::as_str), Some("419"));
assert!(area.region().expect("a region").is_area());
}
#[test]
fn the_tail_is_held_verbatim_and_rendered_back() {
for tag in [
"en-US-posix",
"de-u-co-phonebk",
"en-x-lorem",
"sl-rozaj-biske",
"en-US-x-Foo",
"hy-Latn-IT-arevela",
] {
assert_eq!(canonical(tag), tag, "`{tag}` did not round-trip");
}
let held = admitted("en-US-x-Foo");
assert_eq!(held.language().as_str(), "en");
assert_eq!(held.region().map(Region::as_str), Some("US"));
assert_eq!(held.rest().map(Utf8Bytes::as_str), Some("x-Foo"));
}
#[test]
fn two_spellings_of_one_tail_are_two_values() {
let upper = admitted("en-US-x-Foo");
let lower = admitted("en-US-x-foo");
assert_ne!(upper, lower);
assert_eq!(upper.language(), lower.language());
assert_eq!(upper.region(), lower.region());
assert_eq!(admitted("EN-us-x-Foo"), upper);
}
#[test]
fn an_extlang_rides_the_tail_and_takes_the_later_seats_with_it() {
let cantonese = admitted("zh-yue");
assert_eq!(cantonese.language().as_str(), "zh");
assert_eq!(cantonese.rest().map(Utf8Bytes::as_str), Some("yue"));
assert_eq!(cantonese.to_string(), "zh-yue");
let swallowed = admitted("zh-yue-Hant-HK");
assert_eq!(swallowed.language().as_str(), "zh");
assert_eq!(swallowed.script(), None, "the script is IN the tail");
assert_eq!(swallowed.region(), None, "and so is the region");
assert_eq!(swallowed.rest().map(Utf8Bytes::as_str), Some("yue-Hant-HK"));
assert_eq!(swallowed.to_string(), "zh-yue-Hant-HK", "lossless anyway");
let plain = admitted("zh-Hant-HK");
assert_eq!(plain.script().map(ScriptSubtag::as_str), Some("Hant"));
assert_eq!(plain.region().map(Region::as_str), Some("HK"));
}
#[test]
fn the_tail_admits_what_is_alphanumeric_and_refuses_what_is_not() {
assert_eq!(
canonical("en-USA"),
"en-USA",
"not a legal variant, and carried"
);
assert_eq!(canonical("de-1901"), "de-1901");
assert_eq!(canonical("en-a-bbb-x-a-ccc"), "en-a-bbb-x-a-ccc");
assert_eq!(door("en-US-!!"), Err(ParseLanguageIdError::Tail('!')));
assert_eq!(door("en-US-po six"), Err(ParseLanguageIdError::Tail(' ')));
assert_eq!(
door("en-US-abcdefghi"),
Err(ParseLanguageIdError::TailWidth)
);
assert!(door("en-US-abcdefgh").is_ok(), "eight is the ceiling");
}
#[test]
fn a_grandfathered_tag_with_no_replacement_falls_through_to_the_ordinary_parse() {
assert_eq!(canonical("cel-gaulish"), "cel-gaulish");
assert_eq!(admitted("cel-gaulish").language().as_str(), "cel");
assert_eq!(
admitted("cel-gaulish").rest().map(Utf8Bytes::as_str),
Some("gaulish")
);
assert_eq!(canonical("zh-min"), "zh-min");
assert_eq!(
admitted("zh-min").rest().map(Utf8Bytes::as_str),
Some("min")
);
for refused in ["i-default", "i-mingo", "i-enochian"] {
assert_eq!(
door(refused),
Err(ParseLanguageIdError::Language(ParseLanguageError::TooShort)),
"`{refused}`"
);
}
}
#[test]
fn the_grandfathered_table_fits_the_lookup_buffer() {
let widest = registry::table::GRANDFATHERED
.iter()
.map(|(tag, _)| tag.len())
.chain(
registry::table::GRANDFATHERED_KEPT
.iter()
.map(|tag| tag.len()),
)
.max()
.expect("twenty-six of them");
assert!(
widest <= super::GRANDFATHERED_MAX,
"the widest grandfathered tag is {widest} bytes and the buffer is {}",
super::GRANDFATHERED_MAX
);
}
#[test]
fn a_refusal_names_the_seat_and_carries_its_error() {
assert_eq!(door(""), Err(ParseLanguageIdError::Empty));
assert_eq!(door("en-"), Err(ParseLanguageIdError::EmptySubtag));
assert_eq!(door("en--US"), Err(ParseLanguageIdError::EmptySubtag));
assert_eq!(door("-en"), Err(ParseLanguageIdError::EmptySubtag));
assert_eq!(
door("e-US"),
Err(ParseLanguageIdError::Language(ParseLanguageError::TooShort))
);
assert_eq!(
door("日本語-JP"),
Err(ParseLanguageIdError::Language(
ParseLanguageError::NotAlphabetic('日')
))
);
assert_eq!(canonical("zh-Hans-XYZ"), "zh-Hans-XYZ", "the tail took it");
assert_eq!(
canonical("de-1a1"),
"de-1a1",
"neither two letters nor three digits"
);
assert_eq!(
admitted("de-1a1").rest().map(Utf8Bytes::as_str),
Some("1a1")
);
assert_eq!(admitted("de-1a1").region(), None);
}
#[test]
fn two_spellings_of_one_identity_are_one_value() {
let mkv = admitted("GER-latn-de");
let mp4 = admitted("deu-Latn-DE");
let bcp47 = admitted("de-DE");
assert_eq!(mkv, mp4);
assert_eq!(mp4, bcp47);
let mut distinct = std::collections::HashSet::new();
distinct.insert(mkv);
distinct.insert(mp4);
distinct.insert(bcp47);
assert_eq!(distinct.len(), 1, "one identity, one hash bucket");
assert_ne!(admitted("de"), admitted("de-DE"));
}
#[test]
fn the_rendering_and_the_parse_are_inverse() {
for sent in [
"de",
"zh-Hans",
"en-US",
"sr-Cyrl-RS",
"en-US-x-Foo",
"GER-latn-de",
"i-klingon",
"zh_Hans_CN",
] {
let held = admitted(sent);
let rendered = held.to_string();
assert_eq!(LanguageId::from_str(&rendered).expect("canonical"), held);
assert_eq!(admitted(&rendered), held, "the door is idempotent");
}
assert_eq!(
format!("{:?}", admitted("GER-latn-de")),
r#"LanguageId("de-DE")"#
);
}
#[test]
fn building_an_identity_by_parts_applies_the_same_rules() {
let english = Language::new("en").expect("a language");
let latin = ScriptSubtag::new("Latn").expect("a script");
let composed = LanguageId::compose(english.clone(), Some(latin), None, None);
assert_eq!(composed, admitted("en"));
assert_eq!(composed.script(), None, "the suppression fired");
let chinese = Language::new("zh").expect("a language");
let simplified = ScriptSubtag::new("Hans").expect("a script");
let composed = LanguageId::compose(chinese, Some(simplified), None, None);
assert_eq!(composed, admitted("zh-Hans"));
assert_eq!(LanguageId::from(english), admitted("en"));
}
#[test]
fn the_region_seats_error_has_a_route_to_the_surface() {
let refused = ParseLanguageIdError::Region(ParseRegionError::Mixed);
assert!(refused.to_string().contains("region subtag"));
assert!(core::error::Error::source(&refused).is_some());
let language = ParseLanguageIdError::Language(ParseLanguageError::Empty);
assert!(core::error::Error::source(&language).is_some());
assert!(core::error::Error::source(&ParseLanguageIdError::Empty).is_none());
}
#[test]
fn ordering_walks_the_seats_in_order() {
let mut sorted = [
admitted("de-DE"),
admitted("de"),
admitted("de-AT"),
admitted("zh-Hans"),
admitted("zh"),
];
sorted.sort();
let tags: Vec<String> = sorted.iter().map(LanguageId::to_string).collect();
assert_eq!(tags, ["de", "de-AT", "de-DE", "zh", "zh-Hans"]);
}