vendor/bytecount/tests/check.rs

   1 extern crate bytecount;
   2 #[macro_use]
   3 extern crate quickcheck;
   4 extern crate rand;
   5
   6 use bytecount::{
   7     count, naive_count,
   8     num_chars, naive_num_chars,
   9 };
  10 use rand::RngCore;
  11
  12 fn random_bytes(len: usize) -> Vec<u8> {
  13     let mut result = vec![0; len];
  14     rand::thread_rng().fill_bytes(&mut result);
  15     result
  16 }
  17
  18 quickcheck! {
  19     fn check_count_correct(x: (Vec<u8>, u8)) -> bool {
  20         let (haystack, needle) = x;
  21         count(&haystack, needle) == naive_count(&haystack, needle)
  22     }
  23 }
  24
  25 #[test]
  26 fn check_count_large() {
  27     let haystack = vec![0u8; if cfg!(miri) { 2_000 } else { 10_000_000 }];
  28     assert_eq!(naive_count(&haystack, 0), count(&haystack, 0));
  29     assert_eq!(naive_count(&haystack, 1), count(&haystack, 1));
  30 }
  31
  32 #[test]
  33 fn check_count_large_rand() {
  34     let haystack = random_bytes(if cfg!(miri) { 200 } else { 100_000 });
  35     for i in 0..=255 {
  36         assert_eq!(naive_count(&haystack, i), count(&haystack, i));
  37     }
  38 }
  39
  40 #[test]
  41 fn check_count_some() {
  42     let haystack = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68];
  43     let needle = 68;
  44     assert_eq!(count(&haystack, needle), naive_count(&haystack, needle));
  45 }
  46
  47 #[test]
  48 fn check_count_overflow() {
  49     let haystack = vec![0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  50     let needle = 2;
  51     assert_eq!(count(&haystack, needle), naive_count(&haystack, needle));
  52 }
  53
  54 #[test]
  55 fn check_count_overflow_many() {
  56     let string = [b'x'; 20000];
  57     for i in 0..20000 {
  58         assert_eq!(count(&string[..i], b'x'), i);
  59     }
  60 }
  61
  62
  63
  64 quickcheck! {
  65     fn check_num_chars_correct(haystack: Vec<u8>) -> bool {
  66         num_chars(&haystack) == naive_num_chars(&haystack)
  67     }
  68 }
  69
  70 #[test]
  71 fn check_num_chars_large() {
  72     let haystack = vec![0u8; if cfg!(miri) { 2_000 } else { 10_000_000 }];
  73     assert_eq!(naive_num_chars(&haystack), num_chars(&haystack));
  74     assert_eq!(naive_num_chars(&haystack), num_chars(&haystack));
  75 }
  76
  77 #[test]
  78 fn check_num_chars_some() {
  79     let haystack = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68];
  80     assert_eq!(num_chars(&haystack), naive_num_chars(&haystack));
  81 }
  82
  83 #[test]
  84 fn check_num_chars_overflow() {
  85     let haystack = vec![0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
  86     assert_eq!(num_chars(&haystack), naive_num_chars(&haystack));
  87 }
  88
  89 #[test]
  90 fn check_num_chars_overflow_many() {
  91     let string = [b'x'; 20000];
  92     for i in 0..20000 {
  93         assert_eq!(num_chars(&string[..i]), i);
  94     }
  95 }