use super::{
ASCII, CharSet, HAZARD, SETS, SetDefinition, SetMember, ascii,
ascii_definition, catalog, definitions, hazard_catalog, intrinsic_catalog,
};
#[test]
fn ascii_grants_printable_text() {
let set = ascii();
assert!(set.contains('\u{0020}'));
assert!(set.contains('\u{0041}'));
assert!(set.contains('\u{007E}'));
}
#[test]
fn ascii_grants_tab_and_newline() {
let set = ascii();
assert!(set.contains('\u{0009}'));
assert!(set.contains('\u{000A}'));
}
#[test]
fn ascii_withholds_carriage_return_and_other_controls() {
let set = ascii();
assert!(!set.contains('\u{000D}'));
assert!(!set.contains('\u{0000}'));
assert!(!set.contains('\u{001F}'));
assert!(!set.contains('\u{007F}'));
}
#[test]
fn ascii_withholds_everything_above_ascii() {
let set = ascii();
assert!(!set.contains('\u{00A0}'));
assert!(!set.contains('\u{2014}'));
assert!(!set.contains('\u{1F600}'));
}
#[test]
fn the_definition_resolves_to_the_same_set() {
assert_eq!(ascii_definition().name, ASCII);
assert_eq!(ascii().ranges.len(), 2);
}
#[test]
fn the_intrinsic_catalog_composes_the_same_set() {
assert_eq!(intrinsic_catalog().resolve(ASCII, TEXT), Ok(ascii()));
}
#[test]
fn the_intrinsic_catalog_declares_only_ascii() {
let catalog = intrinsic_catalog();
let listed = catalog.names().collect::<Vec<_>>();
assert_eq!(listed, vec![ASCII]);
}
const TEXT: &str = "text";
const DECLARED: [&str; 16] = [
"any",
"arabic",
"box",
"caveman",
"cr",
"cyrillic",
"emoji",
"greek",
"hazard",
"hindi",
"latin-ext",
"latin1",
"legal",
"marks",
"math",
"persian",
];
fn declared() -> Vec<SetDefinition> {
let parsed = definitions();
assert!(parsed.is_ok(), "the compiled-in data file must parse");
parsed.unwrap_or_default()
}
fn preset(name: &str) -> CharSet {
preset_at(name, TEXT)
}
fn preset_at(name: &str, family: &str) -> CharSet {
let resolved = catalog()
.ok()
.and_then(|sets| sets.resolve(name, family).ok());
assert!(resolved.is_some(), "{name} must resolve");
resolved.unwrap_or_else(|| CharSet::new(name.to_owned(), Vec::new()))
}
#[test]
fn the_data_file_parses() {
assert!(definitions().is_ok());
}
#[test]
fn the_data_file_is_pure_ascii() {
assert!(SETS.is_ascii());
}
fn is_code_point(member: &SetMember, builtin: &[String]) -> bool {
match member {
SetMember::Range(_) => true,
SetMember::Labelled { member, .. } => is_code_point(member, builtin),
SetMember::Named(name) => builtin.contains(name),
SetMember::Literal(_) => false,
}
}
#[test]
fn every_member_is_written_as_a_code_point() {
let names: Vec<String> = declared().into_iter().map(|d| d.name).collect();
for definition in declared() {
for member in &definition.members {
assert!(
is_code_point(member, &names),
"{} holds a member that is not U+XXXX",
definition.name
);
}
}
}
#[test]
fn every_preset_the_spec_names_is_declared_and_grants_something() {
for name in DECLARED {
assert!(!preset(name).is_empty(), "{name} grants nothing");
}
assert!(!preset("typography").is_empty());
}
#[test]
fn the_data_file_declares_no_set_twice() {
let mut names: Vec<String> =
declared().into_iter().map(|set| set.name).collect();
let total = names.len();
names.sort_unstable();
names.dedup();
assert_eq!(names.len(), total);
}
#[test]
fn the_data_file_does_not_declare_ascii() {
let ascii_declared = declared().iter().any(|set| set.name == ASCII);
assert!(!ascii_declared);
}
#[test]
fn the_catalog_carries_ascii_as_well_as_the_presets() {
assert_eq!(preset(ASCII), ascii());
assert!(catalog().is_ok_and(|sets| sets.get("caveman").is_some()));
}
#[test]
fn caveman_grants_the_format_symbols() {
let set = preset("caveman");
assert!(set.contains('\u{2192}'));
assert!(set.contains('\u{22A5}'));
assert!(set.contains('\u{00A7}'));
}
#[test]
fn caveman_grants_the_measured_symbols_too() {
let set = preset("caveman");
assert!(set.contains('\u{21D2}'));
assert!(set.contains('\u{2235}'));
assert!(set.contains('\u{00B7}'));
assert!(!set.contains('\u{1F600}'));
}
#[test]
fn caveman_grants_the_wave_one_gap() {
let set = preset("caveman");
assert!(set.contains('\u{2261}'));
assert!(set.contains('\u{03A3}'));
assert!(set.contains('\u{27FA}'));
assert!(set.contains('\u{2287}'));
assert!(!set.contains('\u{226A}'));
}
#[test]
fn box_grants_both_drawing_blocks() {
let set = preset("box");
assert!(set.contains('\u{250C}'));
assert!(set.contains('\u{257F}'));
assert!(set.contains('\u{25A0}'));
assert!(!set.contains('\u{2580}'));
}
#[test]
fn typography_grants_what_the_builtin_map_targets() {
let set = preset("typography");
assert!(set.contains('\u{2014}'));
assert!(set.contains('\u{2019}'));
assert!(set.contains('\u{201D}'));
assert!(set.contains('\u{2026}'));
assert!(set.contains('\u{00A0}'));
assert!(set.contains('\u{2212}'));
}
#[test]
fn typography_grants_the_low_9_quotes_the_map_targets() {
let set = preset("typography");
let quotes = ['\u{201A}', '\u{201B}', '\u{201E}', '\u{201F}'];
assert!(quotes.iter().all(|quote| set.contains(*quote)));
}
#[test]
fn emoji_grants_single_code_points_and_withholds_the_joiners() {
let set = preset("emoji");
assert!(set.contains('\u{1F600}'));
assert!(set.contains('\u{2600}'));
assert!(!set.contains('\u{200D}'));
assert!(!set.contains('\u{FE0F}'));
assert!(!set.contains('\u{1F3FB}'));
assert!(!set.contains('\u{20E3}'));
}
#[test]
fn cr_grants_only_the_carriage_return() {
let set = preset("cr");
assert!(set.contains('\u{000D}'));
assert_eq!(set.ranges.len(), 1);
}
#[test]
fn a_coarse_block_grants_its_whole_block() {
assert!(preset("latin1").contains('\u{00E9}'));
assert!(preset("latin-ext").contains('\u{0142}'));
assert!(preset("cyrillic").contains('\u{0416}'));
assert!(preset("greek").contains('\u{03B1}'));
assert!(preset("arabic").contains('\u{0645}'));
}
#[test]
fn any_grants_every_code_point_there_is() {
let set = preset("any");
assert!(set.contains('\u{0000}'));
assert!(set.contains('\u{E000}'));
assert!(set.contains('\u{10FFFF}'));
}
#[test]
fn a_preset_is_a_handful_of_ranges() {
for name in DECLARED {
let ranges = preset(name).ranges.len();
assert!(ranges <= 32, "{name} holds {ranges} ranges");
}
}
#[test]
fn marks_grants_the_text_spelling_at_text_fidelity() {
let set = preset("marks");
assert!(set.contains('\u{2713}'));
assert!(set.contains('\u{2717}'));
assert!(!set.contains('\u{2705}'));
assert!(!set.contains('\u{274C}'));
}
#[test]
fn marks_grants_the_emoji_spelling_at_emoji_fidelity() {
let set = preset_at("marks", "emoji");
assert!(set.contains('\u{2705}'));
assert!(set.contains('\u{274C}'));
assert!(!set.contains('\u{2713}'));
assert!(!set.contains('\u{2717}'));
}
#[test]
fn an_unlabelled_member_survives_every_fidelity() {
assert!(preset("marks").contains('\u{26A0}'));
assert!(preset_at("marks", "emoji").contains('\u{26A0}'));
assert!(preset_at("marks", "nerd").contains('\u{26A0}'));
}
#[test]
fn an_unknown_family_grants_only_what_carries_no_label() {
let set = preset_at("marks", "nerd");
assert_eq!(set.ranges.len(), 1);
assert!(!set.contains('\u{2713}'));
assert!(!set.contains('\u{2705}'));
}
const HAZARD_CLASSES: [&str; 5] = [
"hazard-bidi",
"hazard-tag",
"hazard-bom",
"hazard-control",
"hazard-invisible",
];
fn hazard_class(name: &str) -> CharSet {
let resolved = hazard_catalog()
.ok()
.and_then(|sets| sets.resolve(name, TEXT).ok());
assert!(resolved.is_some(), "{name} must resolve on its own");
resolved.unwrap_or_else(|| CharSet::new(name.to_owned(), Vec::new()))
}
fn size(set: &CharSet) -> usize {
set.ranges.iter().map(|r| (r.start..=r.end).count()).sum()
}
#[test]
fn the_hazard_file_is_ascii_and_reads_without_the_presets() {
assert!(HAZARD.is_ascii());
assert!(SETS.ends_with(HAZARD));
for name in HAZARD_CLASSES {
assert!(!hazard_class(name).is_empty(), "{name} is empty");
}
let listed = hazard_catalog().map(|c| c.names().count());
assert_eq!(listed, Ok(6));
}
#[test]
fn the_ignorable_class_holds_exactly_what_unicode_counts() {
assert_eq!(size(&hazard_class("hazard-invisible")), 4174);
}
const V34_MEMBERS: &str = "\u{200B}\u{200D}\u{00AD}\u{FE0F}\u{3164}\
\u{2061}\u{202E}\u{2066}\u{E0041}\u{0007}\u{001B}\u{007F}\
\u{009B}\u{FEFF}";
#[test]
fn hazard_holds_every_class_v34_names_and_keeps_the_layout_controls() {
let set = preset("hazard");
for point in V34_MEMBERS.chars() {
assert!(set.contains(point), "U+{:04X}", u32::from(point));
}
for point in ['\t', '\n', '\r', ' ', 'A', '\u{00A0}', '\u{1F3FD}'] {
assert!(!set.contains(point), "U+{:04X}", u32::from(point));
}
}
#[test]
fn the_catalog_hazard_is_the_hazard_the_lint_reads() {
assert_eq!(preset("hazard"), hazard_class("hazard"));
}
#[test]
fn each_hazard_class_holds_its_own_members() {
assert!(hazard_class("hazard-bidi").contains('\u{202E}'));
assert!(hazard_class("hazard-bidi").contains('\u{200F}'));
assert!(!hazard_class("hazard-bidi").contains('\u{200B}'));
assert_eq!(size(&hazard_class("hazard-tag")), 128);
assert_eq!(size(&hazard_class("hazard-bom")), 1);
assert_eq!(size(&hazard_class("hazard-control")), 62);
}
#[test]
fn the_library_catalog_holds_presets_and_locales() {
let mut built = catalog().unwrap_or_default();
assert!(super::super::adopt_all(&mut built).is_ok());
let library = super::SetCatalog::builtin();
assert_eq!(library, built);
assert!(library.resolve("caveman", "text").is_ok());
assert!(library.resolve("pl", "text").is_ok());
}
#[test]
fn every_vendored_emoji_sequence_decodes() {
use super::SequenceKind::{Flag, Keycap, Presentation, Tag, Zwj};
let all: Vec<_> = super::emoji_sequences().collect();
let count = |kind| all.iter().filter(|s| s.kind == kind).count();
let kinds = [Zwj, Tag, Keycap, Presentation, Flag].map(count);
assert_eq!(kinds, [1614, 3, 12, 207, 259]);
let heart = all.iter().find(|s| s.text == "\u{2764}\u{FE0F}");
assert_eq!(heart.map(|s| s.kind), Some(Presentation));
}
const GENERATORS: [&str; 2] = [
include_str!("locale/cldr-letters.sh"),
include_str!("emoji-sequences.sh"),
];
#[test]
fn every_generator_fetch_makes_its_dir_and_reports_failure() {
for script in GENERATORS {
let body = script.split_once("\nfetch() {\n").map(|(_, b)| b);
assert!(body.is_some_and(|b| b.starts_with(" mkdir -p \"$1\"\n")));
assert!(script.contains("curl -sSfL") && !script.contains("curl -sfL"));
}
}
#[test]
fn every_builtin_preset_has_exactly_one_description() {
let described: Vec<&str> = super::described().map(|(n, _)| n).collect();
let built = catalog().unwrap_or_default();
let mut declared: Vec<&str> = built.names().collect();
let mut listed = described.clone();
declared.sort_unstable();
listed.sort_unstable();
assert_eq!(listed, declared);
assert!(described.first() == Some(&"ascii"));
assert!(super::described().all(|(_, said)| !said.trim().is_empty()));
}