Cover the branches the accuracy work added

CI enforces 100% line coverage on Linux and the branch had dropped to 99.63%.
Add unit tests for the paths that had none: the print-variant folding and the
slash-joined compatibility unit, the closed-enclosure scan, the dictionaryless
`ever` shape, the spaced-colon lookahead, the Korean name before a
parenthetical, the word-shortcut no-op, and the Greek, quoted-number, emphasis,
bullet, parenthesis, signed-number and label-colon routes.

Author: devfive

libs/braillify/src/english_logic.rs

@@ -961,3 +961,35 @@ mod tests {
         let _ = super::should_keep_english_mode_for_symbol('@', &chars, 4, &[]);
     }
 }
+
+#[cfg(test)]
+mod enclosure_route_coverage {
+    use super::*;
+
+    /// 제46항 `BMI(체질량 지수)`: a closed enclosure is Korean punctuation
+    /// unless its body is Roman letters (제32항 `ABC(def)`).
+    #[rstest::rstest]
+    #[case::korean_body(&['(', '체', '질', '량', ')'], true)]
+    #[case::digits_only(&['(', '7', '3', ')'], true)]
+    #[case::roman_body(&['(', 'd', 'e', 'f', ')'], false)]
+    #[case::nested_roman(&['(', '(', 'd', ')', 'e', ')'], false)]
+    #[case::never_closes(&['(', 'd', 'e', 'f'], false)]
+    fn closed_enclosure_is_korean_unless_its_body_is_roman(
+        #[case] word: &[char],
+        #[case] expected: bool,
+    ) {
+        assert_eq!(
+            closed_parenthesis_is_korean_punctuation(word, 0, &[]),
+            expected
+        );
+    }
+
+    #[test]
+    fn an_enclosure_closing_in_a_later_word_is_still_scanned() {
+        assert!(closed_parenthesis_is_korean_punctuation(
+            &['(', 'A'],
+            0,
+            &["체질량)"]
+        ));
+    }
+}

libs/braillify/src/lib.rs

@@ -3075,3 +3075,51 @@ mod debug_reader {
         }
     }
 }
+
+#[cfg(test)]
+mod print_variant_coverage {
+    use super::*;
+
+    #[rstest::rstest]
+    #[case::celsius("25\u{00B0}C", "25\u{2103}")]
+    #[case::fahrenheit("77\u{00B0}F", "77\u{2109}")]
+    #[case::ring_celsius("25\u{02DA}C", "25\u{2103}")]
+    #[case::ring_fahrenheit("77\u{02DA}F", "77\u{2109}")]
+    fn degree_letter_pair_folds_to_the_unit_glyph(#[case] input: &str, #[case] expected: &str) {
+        assert_eq!(
+            normalize_print_variants(std::borrow::Cow::Borrowed(input)).as_ref(),
+            expected
+        );
+    }
+
+    #[rstest::rstest]
+    #[case::fullwidth_percent('\u{FF05}', true)]
+    #[case::fullwidth_letter('\u{FF4D}', true)]
+    #[case::fullwidth_hash_is_the_math_cardinal('\u{FF03}', false)]
+    #[case::fullwidth_colon_is_the_old_hangul_mark('\u{FF1A}', false)]
+    #[case::ascii_is_not_a_variant('m', false)]
+    fn fullwidth_folding_excludes_the_two_reserved_glyphs(
+        #[case] input: char,
+        #[case] expected: bool,
+    ) {
+        assert_eq!(is_foldable_fullwidth(input), expected);
+    }
+
+    #[rstest::rstest]
+    #[case::before_slash("\u{338F}/h")]
+    #[case::after_slash("h/\u{338F}")]
+    fn a_square_unit_joined_through_a_slash_decomposes(#[case] input: &str) {
+        let folded = normalize_pure_roman_compatibility_units(std::borrow::Cow::Borrowed(input));
+        assert!(
+            folded.contains("kg"),
+            "expected the unit to spell out, got {folded:?}"
+        );
+    }
+
+    #[test]
+    fn a_detached_square_unit_keeps_its_glyph() {
+        let folded =
+            normalize_pure_roman_compatibility_units(std::borrow::Cow::Borrowed("\u{338F}"));
+        assert_eq!(folded.as_ref(), "\u{338F}");
+    }
+}

libs/braillify/src/rules/emit.rs

@@ -1,4 +1,4 @@
-use crate::char_struct::{CharType, KoreanChar};
+use crate::char_struct::{CharType, KoreanChar};
 use crate::english_logic;
 use crate::fraction;
 use crate::rules::context::{EncoderState, RuleContext};
@@ -2128,3 +2128,47 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod spaced_colon_coverage {
+    use super::*;
+    use crate::rules::token::{SpaceKind, WordMeta};
+
+    fn word(text: &str) -> Token<'static> {
+        let chars: Vec<char> = text.chars().collect();
+        Token::Word(WordToken {
+            text: std::borrow::Cow::Owned(text.to_string()),
+            meta: WordMeta::from_chars(&chars),
+            chars,
+        })
+    }
+
+    /// 제29항·제32항·제35항: a standalone colon joins two Roman items only when
+    /// the item after it is proved Roman.
+    #[test]
+    fn a_roman_item_after_the_colon_connects_the_section() {
+        let tokens = [word(":"), Token::Space(SpaceKind::Regular), word("Beta")];
+        assert!(spaced_colon_connects_roman_items(&tokens, 0));
+    }
+
+    #[test]
+    fn a_korean_item_after_the_colon_breaks_the_section() {
+        let tokens = [word(":"), Token::Space(SpaceKind::Regular), word("베타")];
+        assert!(!spaced_colon_connects_roman_items(&tokens, 0));
+    }
+
+    #[test]
+    fn a_pre_encoded_item_after_the_colon_breaks_the_section() {
+        let tokens = [word(":"), Token::PreEncoded(vec![1])];
+        assert!(!spaced_colon_connects_roman_items(&tokens, 0));
+    }
+
+    #[test]
+    fn a_token_that_is_not_a_lone_colon_never_connects() {
+        assert!(!spaced_colon_connects_roman_items(&[word("::")], 0));
+        assert!(!spaced_colon_connects_roman_items(
+            &[Token::PreEncoded(vec![1])],
+            0
+        ));
+    }
+}

libs/braillify/src/rules/english_ueb/engine/word_methods.rs

@@ -1033,3 +1033,15 @@ mod tests {
         assert!(out.starts_with(&[GRADE1, CAPITAL, CAPITAL]));
     }
 }
+
+#[cfg(test)]
+mod word_body_coverage {
+    /// §10.9: a whole-word shortform is written by its own cells; any other
+    /// word falls through to the ordinary contraction encoder.
+    #[rstest::rstest]
+    #[case::whole_word_shortform("그는 about 를")]
+    #[case::ordinary_word("그는 tomato 를")]
+    fn a_roman_word_in_korean_text_encodes(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}

libs/braillify/src/rules/english_ueb/rule_10_7_pron.rs

@@ -649,3 +649,20 @@ mod tests {
         assert!(!contains_contiguous(&[], &[]));
     }
 }
+
+#[cfg(test)]
+mod ever_shape_coverage {
+    /// §10.7: with no dictionary entry the `ever` sign is decided by shape —
+    /// word-final, or with a single inflectional `s` left.
+    #[rstest::rstest]
+    #[case::word_final("그는 cantilever 를", "⠐⠑")]
+    #[case::inflected_s("그는 Clevers 를", "⠐⠑")]
+    #[case::longer_tail("그는 Cleverse 를", "⠑⠧⠻")]
+    fn dictionaryless_ever_follows_the_word_edge(#[case] input: &str, #[case] expected: &str) {
+        let encoded = crate::encode_to_unicode(input).unwrap();
+        assert!(
+            encoded.contains(expected),
+            "expected {expected} in {encoded}"
+        );
+    }
+}

libs/braillify/src/rules/korean/rule_28.rs

@@ -794,3 +794,16 @@ mod tests {
         assert!(matches!(outcome, RuleResult::Skip));
     }
 }
+
+#[cfg(test)]
+mod uppercase_run_coverage {
+    /// UEB 10.12.1: an all-capitals initialism in Korean text is spelled with
+    /// alphabet signs; a mixed-case Roman run keeps its ordinary route.
+    #[rstest::rstest]
+    #[case::initialism("그는 WHO 를")]
+    #[case::hyphenated_run("그는 CV3-AD685 를")]
+    #[case::mixed_case("그는 Lincoln 을")]
+    fn a_roman_run_in_korean_text_encodes(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}

libs/braillify/src/rules/korean/rule_31.rs

@@ -196,3 +196,14 @@ mod tests {
         assert!(!result.is_empty());
     }
 }
+
+#[cfg(test)]
+mod greek_run_coverage {
+    /// 제31항: Greek letters take their own cells, alone or in a run.
+    #[rstest::rstest]
+    #[case::single("알파 \u{03B1} 값")]
+    #[case::run("\u{03B1}\u{03B2}\u{03B3}")]
+    fn greek_letters_encode(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}

libs/braillify/src/rules/korean/rule_40.rs

@@ -223,3 +223,16 @@ mod tests {
         assert!(matches!(outcome, RuleResult::Skip));
     }
 }
+
+#[cfg(test)]
+mod number_prefix_coverage {
+    /// 제40항 + 제61항: a number opened after an apostrophe writes the 수표 and
+    /// then the apostrophe cell.
+    #[rstest::rstest]
+    #[case::straight_quote("그는 '2026 년")]
+    #[case::typographic_quote("그는 \u{2019}2026 년")]
+    #[case::plain_number("그는 2026 년")]
+    fn a_number_after_a_quote_encodes(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}

libs/braillify/src/rules/korean/rule_49.rs

@@ -346,3 +346,16 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod emphasis_mark_coverage {
+    /// 제56항 입력 표기: a print source may still carry the `"˙` opening and the
+    /// `__` closing of an emphasis span.
+    #[rstest::rstest]
+    #[case::opening("\"\u{02D9}강조")]
+    #[case::closing("강조__")]
+    #[case::plain_quote("\"강조\"")]
+    fn emphasis_input_notation_encodes(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}

libs/braillify/src/rules/korean/rule_72.rs

@@ -370,3 +370,17 @@ mod tests {
         assert!(matches!(outcome, RuleResult::Skip));
     }
 }
+
+#[cfg(test)]
+mod bullet_tail_coverage {
+    /// 제72항: a bullet owns the item that follows it, whether that item runs
+    /// to the end of the line or stops at punctuation.
+    #[rstest::rstest]
+    #[case::bullet_then_item("\u{25CB} 정원은 넓다")]
+    #[case::bullet_then_punctuation("\u{25CB} 정원.")]
+    #[case::bullet_alone("\u{25CB}")]
+    #[case::bullet_then_bullet("\u{25CB} \u{25A1} 정원")]
+    fn a_bullet_item_encodes(#[case] input: &str) {
+        assert!(crate::encode_to_unicode(input).is_ok());
+    }
+}