use std::sync::LazyLock;
use regex::Regex;
use crate::model::{NameType, NomCode, ParseError, Rank, State};
use crate::pipeline::ParseContext;
use crate::unicode::java_trim;
use crate::viral::is_viral;
static VIRUS: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:(?:viru(?:s|ses)\b|viroid(?:s)?\b|phages?|virion(?:s)?\b|\bsatellite\b|(?:alpha|beta|delta|circular)[\s_-]*satellites?\b|\b(?:Clecru|Milvet|Subclov)satellite\b|bacteriophages?\b|\b[MSC]?NPV\b|\bGV\b|\bICTV\b|(?:fusion\s+)?vector\b|\bprions?\b|\bparticles?\b|\breplicons?\b|\bRNA\b))",
)
.unwrap()
});
static ZOOLOGICAL_BINOMIAL: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^\p{Lu}\p{Ll}+\s+(?:\(\p{Lu}\p{Ll}+\)\s+)?\p{Ll}[\p{Ll}\-]*\s+(?:\([^)]*\)\s*)?\p{Lu}[\p{Lu}.,&'\-\s]*\p{Ll}[\p{L}.,&'\-\s]*\b(1[6-9]\d\d|20\d\d)\b",
)
.unwrap()
});
static CLEAN_BINOMIAL: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^\p{Lu}\p{Ll}+(?:\s+\(\p{Lu}\p{Ll}+\))?\s+\p{Ll}[\p{Ll}\d\-]*$").unwrap()
});
static CLEAN_MONOMIAL: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\p{Lu}[\p{Ll}\-]+$").unwrap());
static SOFT_WORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?:vector|prions?|particles?|replicons?|rna)$").unwrap());
static SOFT_GENUS: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?-u:(?:Vector|Prions?|Particles?|Replicons?|Rna)\b)").unwrap());
static HARD_VIRUS: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:(?:viru(?:s|ses)\b|viroid(?:s)?\b|phages?|virion(?:s)?\b|\bsatellite\b|(?:alpha|beta|delta|circular)[\s_-]*satellites?\b|\b(?:Clecru|Milvet|Subclov)satellite\b|bacteriophages?\b|\b[MSC]?NPV\b|\bGV\b|\bICTV\b))",
)
.unwrap()
});
static HARD_WORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?:virus|viroid|phages?|virion|satellite)$").unwrap());
static AUTH_ZOO: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\(?\p{Lu}\p{Ll}{2,}.*\b(?:1[6-9]\d\d|20\d\d)\b").unwrap());
static OTU_BOLD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^BOLD[:_-][A-Z0-9]+$").unwrap());
static OTU_SH: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^SH(?-u:\d{6,})\.[0-9A-Z.]+$").unwrap());
static OTU_GTDB_UBA: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^(?:UBA|GTDB|GCA|GCF)(?-u:[\d_-]+)$").unwrap());
static OTU_MOTU: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)^(?:z?OTU|ASV|ESV|MAG)(?-u:[ _-]?\d+)$").unwrap());
static CULTURE_ACCESSION_STANDALONE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(&format!(
r"^{}(?-u:[ :=_-]*(?:[A-Z]{{1,4}}-)?\d[\dA-Za-z.:-]*)$",
super::culture_collections::acronym_alternation()
))
.unwrap()
});
static PURE_ALPHANUM: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[\p{L}\d_.\-]+$").unwrap());
static PR2_LIKE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^[\p{L}]+_[\p{L}\-]+(?:-\d+)?$").unwrap());
static GEN_NOV: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)^(?-u:Gen\.?\s*nov\.?(?:\s+(?:sp|species)\.?\s*nov\.?)?\s*)$").unwrap()
});
static OTU_SPECIMEN_SUFFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\bsp\d{8,})$").unwrap());
static PLACEHOLDER_KEYWORDS: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"(?i)(?-u:(?:\(delete\)|\b(?:incertae[\s_]*sedis|inc\.\s*sed\.?|incertaesedis|not\s+assigned|unassigned|unknown|unaccepted|unidentified|undetermined|undet|indet\.?|indeterminate|uncultured|undescribed(?:\s+(?:species|genus|family))?|temp\s+dummy(?:\s+name)?)\b))",
)
.unwrap()
});
static PLACEHOLDER_PREFIX: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"(?i)^(?-u:(?:Unident|Undescribed|IncertaeSedis|Undet)(?:[-\s]|$))").unwrap()
});
static QUESTION_PREFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\?(?-u:\s+)\p{Ll}").unwrap());
static MULTI_QUESTION_PREFIX: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\?(?-u:\s*)\?").unwrap());
static NN_PLACEHOLDER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^N\.(?-u:\s*)[Nn]\.?(?:(?-u:\s*)\(.*\))?(?-u:\s*)$").unwrap());
static INDET_SPECIES: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"^[\p{Lu}][\p{L}\-]+(?:\s+[\p{Lu}][\p{L}]+)?\s+(?:indet|undet)\.?\s*$").unwrap()
});
static CLADE_KEYWORD: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"(?i)(?-u:\bclade\b)").unwrap());
static MONOMIAL_AGGREGATE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^([\p{Lu}][\p{L}]+)(?:-|\s+)(group|complex)$").unwrap());
static LINEAGE_LABEL: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^([\p{L}][\p{L}\d]*)(?:-|\s+)(lineage)$").unwrap());
static HTML_ENTITY_NAMED: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?:&[a-zA-Z]+;)$").unwrap());
static HTML_ENTITY_NUMERIC: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?-u:&#\d+;)$").unwrap());
static DELETE_MARKER: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?:.*(?-u:\s))?delete(?:(?-u:\s).*|,.*|(?-u:\s*))$").unwrap());
static NON_HOMONYM: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^(?i)non(?-u:\s+)\p{Lu}\p{L}+(?:(?-u:\s).*)?$").unwrap());
static QUESTION_ONLY: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^\?(?-u:\s+)\p{Ll}+(?-u:\s*)$").unwrap());
static LATIN_WORD: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[\p{L}][\p{L}.\-]+").unwrap());
static LATIN_WORD_MIN2: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[\p{L}]{2,}").unwrap());
static AUTHOR_ABBREV: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"\b[\p{Lu}][\p{L}]*\.").unwrap());
pub fn run(original: &str, ctx: &mut ParseContext) -> Result<(), ParseError> {
let s: String = java_trim(&ctx.working).to_string();
if s.is_empty() {
return Err(ParseError::new(NameType::Other, None, original));
}
if count_letters(&s) == 1 {
let chars: Vec<char> = s.chars().collect();
let is_abbrev = chars.len() == 2 && chars[1] == '.' && chars[0].is_alphabetic();
if !is_abbrev {
return Err(ParseError::new(NameType::Other, None, original));
}
}
if HTML_ENTITY_NAMED.is_match(&s) || HTML_ENTITY_NUMERIC.is_match(&s) {
return Err(ParseError::new(NameType::Other, None, original));
}
let lower = s.to_lowercase();
if lower.contains("tobedeleted")
|| lower.contains("(delete)")
|| s.starts_with('@')
|| DELETE_MARKER.is_match(&lower)
|| lower.contains("[delete]")
|| lower.contains("[none]")
{
return Err(ParseError::new(NameType::Other, None, original));
}
if lower.starts_with("non ") && (!NON_HOMONYM.is_match(&s) || s.contains('=')) {
return Err(ParseError::new(NameType::Other, None, original));
}
if (PLACEHOLDER_KEYWORDS.is_match(&s)
|| NN_PLACEHOLDER.is_match(&s)
|| PLACEHOLDER_PREFIX.is_match(&s)
|| s.starts_with("[unassigned]")
|| s.eq_ignore_ascii_case("Unaccepted"))
&& !INDET_SPECIES.is_match(&s)
{
return Err(ParseError::new(NameType::Placeholder, None, original));
}
apply_virus_gate(&s, ctx, original)?;
if let Some(caps) = MONOMIAL_AGGREGATE.captures(&s) {
rescue_informal_group(ctx, &caps[1], &caps[2]);
return Ok(());
}
if let Some(caps) = LINEAGE_LABEL.captures(&s) {
if is_clean_genus_stem(&caps[1]) {
rescue_informal_group(ctx, &caps[1], &caps[2]);
return Ok(());
}
return Err(ParseError::new(NameType::Other, None, original));
}
if MULTI_QUESTION_PREFIX.is_match(&s) {
return Err(ParseError::new(NameType::Other, None, original));
}
if QUESTION_PREFIX.is_match(&s) && !INDET_SPECIES.is_match(&s) && QUESTION_ONLY.is_match(&s) {
return Err(ParseError::new(NameType::Placeholder, None, original));
}
if CLADE_KEYWORD.is_match(&s) {
return Err(ParseError::new(NameType::Other, None, original));
}
if OTU_BOLD.is_match(&s)
|| OTU_GTDB_UBA.is_match(&s)
|| OTU_MOTU.is_match(&s)
|| CULTURE_ACCESSION_STANDALONE.is_match(&s)
{
return Err(ParseError::new(NameType::Identifier, None, s));
}
if OTU_SH.is_match(&s) {
return Err(ParseError::new(
NameType::Identifier,
None,
s.to_uppercase(),
));
}
if GEN_NOV.is_match(&s)
|| s.starts_with('@')
{
return Err(ParseError::new(NameType::Other, None, s));
}
if !s.contains(' ')
&& PURE_ALPHANUM.is_match(&s)
&& has_digit(&s)
&& !is_plausible_single_word_name(&s)
{
return Err(ParseError::new(NameType::Other, None, s));
}
if PR2_LIKE.is_match(&s) && s.contains('-') && has_digit(&s) {
return Err(ParseError::new(NameType::Other, None, s));
}
if s.contains(' ') && OTU_SPECIMEN_SUFFIX.is_match(&s) {
return Err(ParseError::new(NameType::Other, None, s));
}
if s.contains(' ') {
let last = last_word(&s);
if OTU_BOLD.is_match(last) {
return Err(ParseError::new(NameType::Other, None, last));
}
if OTU_SH.is_match(last) {
return Err(ParseError::new(NameType::Other, None, last.to_uppercase()));
}
}
if looks_like_hybrid_formula(&s) {
return Err(ParseError::new(NameType::Formula, None, original));
}
Ok(())
}
fn is_clean_genus_stem(stem: &str) -> bool {
stem.chars().next().is_some_and(char::is_uppercase) && stem.chars().all(char::is_alphabetic)
}
fn rescue_informal_group(ctx: &mut ParseContext, taxon: &str, marker: &str) {
ctx.name.genus = Some(taxon.to_string());
ctx.name.rank = Rank::Unranked;
ctx.name.phrase = Some(marker.to_string());
ctx.name.type_ = NameType::Informal;
ctx.name.state = State::Complete;
ctx.preflight_complete = true;
}
fn apply_virus_gate(s: &str, ctx: &mut ParseContext, original: &str) -> Result<(), ParseError> {
let clean = CLEAN_BINOMIAL.is_match(s) || CLEAN_MONOMIAL.is_match(s);
let req = ctx.requested_code;
if clean && is_viral(first_word(s)) {
if req.is_none() || req == Some(NomCode::Virus) {
ctx.viral_shape = true;
}
return Ok(()); }
if !VIRUS.is_match(s) {
return Ok(()); }
if ZOOLOGICAL_BINOMIAL.is_match(s) {
return Ok(());
}
if req == Some(NomCode::Virus) {
if clean {
ctx.viral_shape = true;
return Ok(());
}
return Err(ParseError::new(
NameType::Other,
Some(NomCode::Virus),
original,
));
}
if SOFT_GENUS.is_match(s) && !HARD_VIRUS.is_match(s) {
return Ok(());
}
if clean && req.is_some() {
return Ok(()); }
if clean && SOFT_WORD.is_match(last_word(s)) {
return Ok(()); }
if clean && HARD_WORD.is_match(last_word(s)) {
if let Some(auth) = ctx.authorship_input.as_deref() {
if AUTH_ZOO.is_match(java_trim(auth)) {
return Ok(()); }
}
}
Err(ParseError::new(
NameType::Other,
Some(NomCode::Virus),
original,
))
}
fn first_word(s: &str) -> &str {
match s.find(' ') {
Some(idx) => &s[..idx],
None => s,
}
}
fn last_word(s: &str) -> &str {
match s.rfind(' ') {
Some(idx) => &s[idx + 1..],
None => s,
}
}
fn looks_like_hybrid_formula(s: &str) -> bool {
let cs: Vec<(usize, char)> = s.char_indices().collect();
let n = cs.len();
for i in 0..n {
let c = cs[i].1;
let cross = c == '×';
let ascii_x = !cross
&& (c == 'x' || c == 'X')
&& i > 0
&& i + 1 < n
&& cs[i - 1].1 == ' '
&& cs[i + 1].1 == ' ';
let plus = !cross
&& !ascii_x
&& c == '+'
&& i > 0
&& i + 1 < n
&& cs[i - 1].1 == ' '
&& cs[i + 1].1 == ' ';
if !cross && !ascii_x && !plus {
continue;
}
if i == 0 || cs[i - 1].1 != ' ' {
continue;
}
if i + 1 >= n || cs[i + 1].1 != ' ' {
continue;
}
let left = java_trim(&s[..cs[i].0]);
let right = java_trim(&s[cs[i + 1].0..]);
let right_ok = contains_latin_word(right) || right.starts_with('?');
if !right_ok {
continue;
}
if count_latin_words(left) >= 2 || has_author_abbrev(left) {
return true;
}
if plus
&& count_latin_words(left) == 1
&& !left.is_empty()
&& left.chars().next().is_some_and(|c| c.is_uppercase())
&& !right.is_empty()
&& right.chars().next().is_some_and(|c| c.is_uppercase())
{
return true;
}
}
false
}
fn count_latin_words(s: &str) -> usize {
LATIN_WORD.find_iter(s).count()
}
fn contains_latin_word(s: &str) -> bool {
LATIN_WORD_MIN2.is_match(s)
}
fn has_author_abbrev(s: &str) -> bool {
AUTHOR_ABBREV.is_match(s)
}
fn count_letters(s: &str) -> usize {
s.chars().filter(|c| c.is_alphabetic()).count()
}
fn has_digit(s: &str) -> bool {
s.chars().any(|c| c.is_ascii_digit())
}
fn is_plausible_single_word_name(s: &str) -> bool {
!has_digit(s)
}
#[cfg(test)]
mod tests {
use super::*;
fn check(input: &str) -> Result<(), ParseError> {
let mut ctx = ParseContext::new(input.to_string(), None, None, None);
run(input, &mut ctx)
}
fn rescued(input: &str) -> ParseContext {
let mut ctx = ParseContext::new(input.to_string(), None, None, None);
run(input, &mut ctx).unwrap_or_else(|e| panic!("`{input}` should be rescued, got {e:?}"));
assert!(
ctx.preflight_complete,
"`{input}` should set preflight_complete"
);
ctx
}
#[test]
fn virus_vernacular_name_is_rejected_other_virus() {
let err = check("Tobacco mosaic virus").unwrap_err();
assert_eq!(err.type_, NameType::Other);
assert_eq!(err.code, Some(NomCode::Virus));
}
#[test]
fn soft_genus_prion_is_rescued_and_parses() {
assert!(check("Prion vittatus").is_ok());
}
#[test]
fn zoological_binomial_with_author_year_overrides_stray_viral_token() {
assert!(check("Ceylonesmus vector Chamberlin, 1941").is_ok());
}
#[test]
fn clean_ictv_binomial_parses_with_viral_shape_flag_set() {
let mut ctx = ParseContext::new("Lausannevirus francensis".to_string(), None, None, None);
assert!(run("Lausannevirus francensis", &mut ctx).is_ok());
assert!(ctx.viral_shape);
}
#[test]
fn cross_between_two_binomials_is_a_hybrid_formula() {
let err = check("Homo sapiens x Homo neanderthalensis").unwrap_err();
assert_eq!(err.type_, NameType::Formula);
assert_eq!(err.code, None);
}
#[test]
fn graft_chimera_plus_formula_is_rejected() {
let err = check("Crataegus + Mespilus").unwrap_err();
assert_eq!(err.type_, NameType::Formula);
}
#[test]
fn bold_code_is_classified_identifier() {
let err = check("BOLD:ACW2100").unwrap_err();
assert_eq!(err.type_, NameType::Identifier);
assert_eq!(err.code, None);
}
#[test]
fn sh_code_is_classified_identifier_with_uppercased_name() {
let err = check("sh460441.07fu").unwrap_err();
assert_eq!(err.type_, NameType::Identifier);
assert_eq!(err.name, "SH460441.07FU");
}
#[test]
fn otu_asv_mag_operational_units_are_classified_identifier() {
for s in ["OTU-17", "OTU 34", "ASV_103", "zOTU44", "MAG-24"] {
let err = check(s).unwrap_err();
assert_eq!(
err.type_,
NameType::Identifier,
"{s} should be an IDENTIFIER"
);
}
}
#[test]
fn standalone_culture_collection_accession_is_classified_identifier() {
for s in [
"DSM 10",
"ATCC 11775",
"ATCC BAA-123",
"CBS 123.89",
"LMG 6923T",
"ATCC-11775",
] {
let err = check(s).unwrap_err();
assert_eq!(
err.type_,
NameType::Identifier,
"{s} should be an IDENTIFIER"
);
}
}
#[test]
fn a_genus_starting_with_an_identifier_prefix_is_not_an_identifier() {
assert!(check("Uba fallai Fletcher, 1938").is_ok());
}
#[test]
fn trailing_bold_code_in_multiword_input_is_rejected_with_last_word_as_name() {
let err = check("Festuca sp. BOLD:ACW2100").unwrap_err();
assert_eq!(err.type_, NameType::Other);
assert_eq!(err.name, "BOLD:ACW2100");
}
#[test]
fn monomial_group_aggregate_rescued_to_informal() {
let ctx = rescued("Iteaphila-group");
assert_eq!(ctx.name.type_, NameType::Informal);
assert_eq!(ctx.name.genus.as_deref(), Some("Iteaphila"));
assert_eq!(ctx.name.phrase.as_deref(), Some("group"));
assert_eq!(ctx.name.rank, Rank::Unranked);
assert!(ctx.name.specific_epithet.is_none());
assert_eq!(
rescued("Bartonella group").name.genus.as_deref(),
Some("Bartonella")
);
assert_eq!(
rescued("Foo-complex").name.phrase.as_deref(),
Some("complex")
);
}
#[test]
fn lineage_with_clean_genus_stem_rescued_to_informal() {
let ctx = rescued("Vermistella-lineage");
assert_eq!(ctx.name.type_, NameType::Informal);
assert_eq!(ctx.name.genus.as_deref(), Some("Vermistella"));
assert_eq!(ctx.name.phrase.as_deref(), Some("lineage"));
}
#[test]
fn lineage_with_code_stem_is_unparsable_other() {
assert_eq!(check("NC12A-lineage").unwrap_err().type_, NameType::Other);
assert_eq!(check("he2-lineage").unwrap_err().type_, NameType::Other);
}
#[test]
fn clade_keyword_is_unparsable_other() {
assert_eq!(
check("Amauropeltoid clade").unwrap_err().type_,
NameType::Other
);
assert_eq!(check("Unnamed clade").unwrap_err().type_, NameType::Other);
}
#[test]
fn double_question_mark_prefix_is_other_not_informal() {
let err = check("?? not a name").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn bare_gen_nov_is_other() {
let err = check("Gen.nov.").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn delete_marker_is_other() {
let err = check("Scelotes tobedeleted , 1999").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn html_named_entity_only_is_other() {
let err = check("&").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn single_bare_letter_is_other() {
let err = check("X").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn single_letter_abbreviation_with_dot_is_not_rejected_by_the_letter_count_guard() {
assert!(check("B.").is_ok());
}
#[test]
fn empty_input_is_other() {
let err = check("").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn incertae_sedis_is_placeholder() {
let err = check("incertae sedis").unwrap_err();
assert_eq!(err.type_, NameType::Placeholder);
}
#[test]
fn nn_placeholder_is_placeholder() {
let err = check("N.N.").unwrap_err();
assert_eq!(err.type_, NameType::Placeholder);
}
#[test]
fn single_question_mark_alone_is_placeholder() {
let err = check("? unclassed").unwrap_err();
assert_eq!(err.type_, NameType::Placeholder);
}
#[test]
fn clean_binomial_parses() {
assert!(check("Abies alba").is_ok());
}
#[test]
fn hard_virus_word_is_rescued_by_separately_supplied_zoological_authorship() {
let mut ctx = ParseContext::new(
"Exochus virus".to_string(),
Some("Gauld & Sithole, 2002".to_string()),
None,
None,
);
assert!(run("Exochus virus", &mut ctx).is_ok());
let mut ctx_no_auth = ParseContext::new("Exochus virus".to_string(), None, None, None);
let err = run("Exochus virus", &mut ctx_no_auth).unwrap_err();
assert_eq!(err.type_, NameType::Other);
assert_eq!(err.code, Some(NomCode::Virus));
}
#[test]
fn clean_binomial_with_hard_virus_word_and_requested_non_virus_code_parses() {
let mut ctx = ParseContext::new(
"Exochus virus".to_string(),
None,
None,
Some(NomCode::Zoological),
);
assert!(run("Exochus virus", &mut ctx).is_ok());
}
#[test]
fn requested_virus_code_sets_viral_shape_for_clean_input_and_rejects_non_clean_input() {
let mut ctx = ParseContext::new(
"Exochus virus".to_string(),
None,
None,
Some(NomCode::Virus),
);
assert!(run("Exochus virus", &mut ctx).is_ok());
assert!(ctx.viral_shape);
let mut ctx2 = ParseContext::new(
"Tobacco mosaic virus".to_string(),
None,
None,
Some(NomCode::Virus),
);
let err = run("Tobacco mosaic virus", &mut ctx2).unwrap_err();
assert_eq!(err.type_, NameType::Other);
assert_eq!(err.code, Some(NomCode::Virus));
}
#[test]
fn gca_code_is_classified_identifier() {
let err = check("GCA_000123").unwrap_err();
assert_eq!(err.type_, NameType::Identifier);
}
#[test]
fn non_prefix_followed_by_a_proper_latin_name_is_not_rejected() {
assert!(check("non Linnaeus").is_ok());
}
#[test]
fn non_prefix_with_equals_sign_is_still_rejected() {
let err = check("non Linnaeus = Smith").unwrap_err();
assert_eq!(err.type_, NameType::Other);
}
#[test]
fn question_prefixed_epithet_with_trailing_authorship_is_not_preflight_rejected() {
assert!(check("? gryphoidis Bourguignat 1870").is_ok());
}
#[test]
fn virus_gate_classifies_adversarial_input_without_hanging() {
let adversarial = format!("Rnavirus bus {}", "Aa.-".repeat(30));
let start = std::time::Instant::now();
let _ = check(&adversarial);
assert!(start.elapsed() < std::time::Duration::from_secs(3));
}
}