Track position where normalization failed

Author: clarfonthey

fuzz/fuzz_targets/unicode-normalization.rs

@@ -4,74 +4,66 @@
 extern crate libfuzzer_sys;
 
 use unicode_normalization::{
-    is_nfc, is_nfc_quick, is_nfc_stream_safe, is_nfc_stream_safe_quick, is_nfd, is_nfd_quick,
-    is_nfd_stream_safe, is_nfd_stream_safe_quick, is_nfkc, is_nfkc_quick, is_nfkd, is_nfkd_quick,
-    IsNormalized, UnicodeNormalization,
+    is_nfc, check_nfc_quick, is_nfc_stream_safe, check_nfc_stream_safe_quick, is_nfd, check_nfd_quick,
+    is_nfd_stream_safe, check_nfd_stream_safe_quick, is_nfkc, check_nfkc_quick, is_nfkd, check_nfkd_quick,
+    UnicodeNormalization,
 };
 
-fn from_bool(is_normalized: bool) -> IsNormalized {
-    if is_normalized {
-        IsNormalized::Yes
-    } else {
-        IsNormalized::No
-    }
-}
-
 fuzz_target!(|input: String| {
     // The full predicates imply the quick predicates.
-    assert_ne!(is_nfc_quick(input.chars()), from_bool(!is_nfc(&input)));
-    assert_ne!(is_nfd_quick(input.chars()), from_bool(!is_nfd(&input)));
-    assert_ne!(is_nfkc_quick(input.chars()), from_bool(!is_nfkc(&input)));
-    assert_ne!(is_nfkd_quick(input.chars()), from_bool(!is_nfkd(&input)));
+    assert_ne!(check_nfc_quick(&input).is_ok(), !is_nfc(&input));
+    assert_ne!(check_nfd_quick(&input).is_ok(), !is_nfd(&input));
+    assert_ne!(check_nfkc_quick(&input).is_ok(), !is_nfkc(&input));
+    assert_ne!(check_nfkd_quick(&input).is_ok(), !is_nfkd(&input));
     assert_ne!(
-        is_nfc_stream_safe_quick(input.chars()),
-        from_bool(!is_nfc_stream_safe(&input))
+        check_nfc_stream_safe_quick(&input).is_ok(),
+        !is_nfc_stream_safe(&input)
     );
     assert_ne!(
-        is_nfd_stream_safe_quick(input.chars()),
-        from_bool(!is_nfd_stream_safe(&input))
+        check_nfd_stream_safe_quick(&input).is_ok(),
+        !is_nfd_stream_safe(&input)
     );
 
     // Check NFC, NFD, NFKC, and NFKD normalization.
-    let nfc = input.chars().nfc().collect::<String>();
+    let nfc = input.nfc().collect::<String>();
     assert_eq!(nfc.is_empty(), input.is_empty());
-    assert_ne!(is_nfc_quick(nfc.chars()), IsNormalized::No);
+    assert!(check_nfc_quick(&nfc).is_ok());
     assert!(is_nfc(&nfc));
 
-    let nfd = input.chars().nfd().collect::<String>();
+    let nfd = input.nfd().collect::<String>();
     assert!(nfd.len() >= nfc.len());
-    assert_ne!(is_nfd_quick(nfd.chars()), IsNormalized::No);
+    assert!(check_nfd_quick(&nfd).is_ok());
     assert!(is_nfd(&nfd));
 
-    let nfkc = input.chars().nfkc().collect::<String>();
+    let nfkc = input.nfkc().collect::<String>();
     assert_eq!(nfkc.is_empty(), input.is_empty());
-    assert_ne!(is_nfkc_quick(nfkc.chars()), IsNormalized::No);
+    assert!(check_nfkc_quick(&nfkc).is_ok());
     assert!(is_nfkc(&nfkc));
 
-    let nfkd = input.chars().nfkd().collect::<String>();
+    let nfkd = input.nfkd().collect::<String>();
     assert!(nfkd.len() >= nfkc.len());
-    assert_ne!(is_nfkd_quick(nfkd.chars()), IsNormalized::No);
+    assert!(check_nfkd_quick(&nfkd).is_ok());
     assert!(is_nfkd(&nfkd));
 
     // Check stream-safe.
-    let nfc_ss = nfc.chars().stream_safe().collect::<String>();
+    let nfc_ss = nfc.stream_safe().collect::<String>();
     assert!(nfc_ss.len() >= nfc.len());
-    assert_ne!(is_nfc_stream_safe_quick(nfc_ss.chars()), IsNormalized::No);
+    assert!(check_nfc_stream_safe_quick(&nfc_ss).is_ok());
     assert!(is_nfc_stream_safe(&nfc_ss));
 
-    let nfd_ss = nfd.chars().stream_safe().collect::<String>();
+    let nfd_ss = nfd.stream_safe().collect::<String>();
     assert!(nfd_ss.len() >= nfd.len());
-    assert_ne!(is_nfd_stream_safe_quick(nfd_ss.chars()), IsNormalized::No);
+    assert!(check_nfd_stream_safe_quick(&nfd_ss).is_ok());
     assert!(is_nfd_stream_safe(&nfd_ss));
 
     // Check that NFC and NFD preserve stream-safe.
-    let ss_nfc = input.chars().stream_safe().nfc().collect::<String>();
+    let ss_nfc = input.stream_safe().nfc().collect::<String>();
     assert_eq!(ss_nfc.is_empty(), input.is_empty());
-    assert_ne!(is_nfc_stream_safe_quick(ss_nfc.chars()), IsNormalized::No);
+    assert!(check_nfc_stream_safe_quick(&ss_nfc).is_ok());
     assert!(is_nfc_stream_safe(&ss_nfc));
 
-    let ss_nfd = input.chars().stream_safe().nfd().collect::<String>();
+    let ss_nfd = input.stream_safe().nfd().collect::<String>();
     assert_eq!(ss_nfd.is_empty(), input.is_empty());
-    assert_ne!(is_nfd_stream_safe_quick(ss_nfd.chars()), IsNormalized::No);
+    assert!(check_nfd_stream_safe_quick(&ss_nfd).is_ok());
     assert!(is_nfd_stream_safe(&ss_nfd));
 });

src/lib.rs

@@ -54,9 +54,10 @@ extern crate tinyvec;
 
 pub use crate::decompose::Decompositions;
 pub use crate::quick_check::{
-    is_nfc, is_nfc_quick, is_nfc_stream_safe, is_nfc_stream_safe_quick, is_nfd, is_nfd_quick,
-    is_nfd_stream_safe, is_nfd_stream_safe_quick, is_nfkc, is_nfkc_quick, is_nfkd, is_nfkd_quick,
-    IsNormalized,
+    check_nfc, check_nfc_quick, check_nfc_stream_safe, check_nfc_stream_safe_quick, check_nfd,
+    check_nfd_quick, check_nfd_stream_safe, check_nfd_stream_safe_quick, check_nfkc,
+    check_nfkc_quick, check_nfkd, check_nfkd_quick, is_nfc, is_nfc_stream_safe, is_nfd,
+    is_nfd_stream_safe, is_nfkc, is_nfkd, FullResult, NormalizationError, QuickCheck, QuickResult,
 };
 pub use crate::recompose::Recompositions;
 pub use crate::replace::Replacements;