externcrate 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,

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,

fnfrom_bool(is_normalized:bool) ->IsNormalized{

if is_normalized{

fuzz_target!(|input:String|{

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)

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));

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));

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));

pubusecrate::decompose::Decompositions;

pubusecrate::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,

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,

pubusecrate::recompose::Recompositions;

pubusecrate::replace::Replacements;