Testing, Fuzzing & Benchmarking

/// Run-length encoding: "aaab" -> [('a', 3), ('b', 1)].
pub fn encode(s: &str) -> Vec<(char, usize)> {
    let mut out: Vec<(char, usize)> = Vec::new();
    for c in s.chars() {
        match out.last_mut() {
            Some((last, n)) if *last == c => *n += 1,
            _ => out.push((c, 1)),
        }
    }
    out
}

pub fn decode(runs: &[(char, usize)]) -> String {
    runs.iter().flat_map(|&(c, n)| std::iter::repeat_n(c, n)).collect()
}

fn main() {}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    #[test]
    fn example() {
        assert_eq!(encode("aaab"), vec![('a', 3), ('b', 1)]);
    }

    proptest! {
        #[test]
        fn decode_inverts_encode(s in ".*") {
            prop_assert_eq!(decode(&encode(&s)), s);
        }

        #[test]
        fn runs_never_repeat_a_char(s in "[abc]{0,50}") {
            let runs = encode(&s);
            for pair in runs.windows(2) {
                prop_assert_ne!(pair[0].0, pair[1].0);
            }
        }
    }
}

/// Shortens `s` to at most `max` bytes for a log line.
pub fn truncate(s: &str, max: usize) -> &str {
    if s.len() <= max { s } else { &s[..max] } // BUG: can cut a UTF-8 character in half
}

fn main() {}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    #[test]
    fn ascii_examples_pass() {
        assert_eq!(truncate("hello", 3), "hel");
        assert_eq!(truncate("hi", 10), "hi");
    }

    proptest! {
        #![proptest_config(ProptestConfig { failure_persistence: None, ..ProptestConfig::default() })]

        #[test]
        fn truncate_is_a_prefix_within_max(s in any::<String>(), max in 0usize..20) {
            let t = truncate(&s, max);
            prop_assert!(t.len() <= max);
            prop_assert!(s.starts_with(t));
        }
    }
}

pub fn truncate(s: &str, max: usize) -> &str {
    if s.len() <= max {
        return s;
    }
    let mut end = max;
    while !s.is_char_boundary(end) {
        end -= 1; // back up to the start of the character
    }
    &s[..end]
}

fn main() {}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn truncate_is_a_prefix_within_max(s in any::<String>(), max in 0usize..20) {
            let t = truncate(&s, max);
            prop_assert!(t.len() <= max);
            prop_assert!(s.starts_with(t));
        }
    }
}

use proptest::prelude::*;

#[derive(Debug, Clone, PartialEq)]
enum Currency {
    Eur,
    Usd,
    Inr,
}

#[derive(Debug, Clone)]
struct Order {
    sku: String,
    quantity: u32,
    unit_price_cents: u64,
    currency: Currency,
}

impl Order {
    fn total_cents(&self) -> Option<u64> {
        self.unit_price_cents.checked_mul(self.quantity as u64)
    }
}

fn currency() -> impl Strategy<Value = Currency> {
    prop_oneof![Just(Currency::Eur), Just(Currency::Usd), Just(Currency::Inr)]
}

fn order() -> impl Strategy<Value = Order> {
    ("[A-Z]{3}-[0-9]{4}", 1u32..1_000, 0u64..1_000_000, currency())
        .prop_map(|(sku, quantity, unit_price_cents, currency)| Order { sku, quantity, unit_price_cents, currency })
}

fn main() {}

proptest! {
    #[test]
    fn totals_never_overflow_for_realistic_orders(o in order()) {
        prop_assert!(o.total_cents().is_some());
        prop_assert_eq!(o.sku.len(), 8);
    }

    #[test]
    fn a_basket_total_is_the_sum_of_its_orders(orders in prop::collection::vec(order(), 0..20)) {
        let total: u64 = orders.iter().map(|o| o.total_cents().unwrap()).sum();
        let by_currency: u64 = [Currency::Eur, Currency::Usd, Currency::Inr]
            .iter()
            .map(|c| orders.iter().filter(|o| &o.currency == c).map(|o| o.total_cents().unwrap()).sum::<u64>())
            .sum();
        prop_assert_eq!(total, by_currency);
    }
}

use proptest::prelude::*;
use std::collections::BTreeSet;

/// A set stored as a sorted Vec: fast iteration, compact memory.
#[derive(Default)]
pub struct SortedVecSet {
    items: Vec<i32>,
}

impl SortedVecSet {
    pub fn insert(&mut self, x: i32) -> bool {
        match self.items.binary_search(&x) {
            Ok(_) => false,
            Err(pos) => {
                self.items.insert(pos, x);
                true
            }
        }
    }
    pub fn remove(&mut self, x: i32) -> bool {
        match self.items.binary_search(&x) {
            Ok(pos) => {
                self.items.remove(pos);
                true
            }
            Err(_) => false,
        }
    }
    pub fn contains(&self, x: i32) -> bool {
        self.items.binary_search(&x).is_ok()
    }
}

#[derive(Debug, Clone)]
enum Op {
    Insert(i32),
    Remove(i32),
    Contains(i32),
}

fn op() -> impl Strategy<Value = Op> {
    // Small values, so that inserts, removes, and lookups hit the same elements often.
    let v = -10i32..10;
    prop_oneof![v.clone().prop_map(Op::Insert), v.clone().prop_map(Op::Remove), v.prop_map(Op::Contains)]
}

fn main() {}

proptest! {
    #[test]
    fn behaves_like_btreeset(ops in prop::collection::vec(op(), 0..100)) {
        let mut real = SortedVecSet::default();
        let mut model = BTreeSet::new();
        for op in ops {
            match op {
                Op::Insert(x) => prop_assert_eq!(real.insert(x), model.insert(x)),
                Op::Remove(x) => prop_assert_eq!(real.remove(x), model.remove(&x)),
                Op::Contains(x) => prop_assert_eq!(real.contains(x), model.contains(&x)),
            }
            prop_assert!(real.items.iter().copied().eq(model.iter().copied()));
        }
    }
}

use proptest::prelude::*;

fn slugify(title: &str) -> String {
    let mut slug = String::new();
    for word in title.split(|c: char| !c.is_ascii_alphanumeric()).filter(|w| !w.is_empty()) {
        if !slug.is_empty() {
            slug.push('-');
        }
        slug.push_str(&word.to_ascii_lowercase());
    }
    slug
}

fn main() {}

proptest! {
    // More cases for an important property; the default is 256.
    #![proptest_config(ProptestConfig::with_cases(2_000))]

    #[test]
    fn slugify_is_idempotent(title in "\\PC{0,40}") {
        let once = slugify(&title);
        prop_assert_eq!(slugify(&once), once.clone());
        prop_assert!(once.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-'));
    }
}

// fuzz/fuzz_targets/parse_header.rs
#![no_main]

use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    // Any panic, crash, or sanitizer error is a finding.
    let _ = my_crate::parse_header(data);
});

pub fn parse_header(data: &[u8]) -> Option<(u8, &str)> {
    let version = *data.first()?;
    let len = u16::from_be_bytes([*data.get(1)?, *data.get(2)?]) as usize;
    let name = &data[3..3 + len]; // BUG: trusts the length field
    std::str::from_utf8(name).ok().map(|n| (version, n))
}

fn main() {
    println!("{:?}", parse_header(&[1, 0, 3, b'a', b'b', b'c']));
}

pub fn parse_header(data: &[u8]) -> Option<(u8, &str)> {
    let version = *data.first()?;
    let len = u16::from_be_bytes([*data.get(1)?, *data.get(2)?]) as usize;
    let name = data.get(3..3 + len)?; // fixed: a short buffer is None, not a panic
    std::str::from_utf8(name).ok().map(|n| (version, n))
}

fn main() {}

#[test]
fn fuzz_crash_length_field_longer_than_data() {
    assert_eq!(parse_header(&[176, 10, 44]), None);
}

#[test]
fn valid_header_still_parses() {
    assert_eq!(parse_header(&[1, 0, 3, b'a', b'b', b'c']), Some((1, "abc")));
}

#![no_main]

use arbitrary::Arbitrary;
use libfuzzer_sys::fuzz_target;

#[derive(Debug, Arbitrary)]
enum Op {
    Insert(i32),
    Remove(i32),
    Contains(i32),
}

fuzz_target!(|ops: Vec<Op>| {
    let mut real = my_crate::SortedVecSet::default();
    let mut model = std::collections::BTreeSet::new();
    for op in ops {
        match op {
            Op::Insert(x) => assert_eq!(real.insert(x), model.insert(x)),
            Op::Remove(x) => assert_eq!(real.remove(x), model.remove(&x)),
            Op::Contains(x) => assert_eq!(real.contains(x), model.contains(&x)),
        }
    }
});

/// Sums the numbers in a comma-separated line, allocating a String per field first.
pub fn sum_collect(line: &str) -> u64 {
    let parts: Vec<String> = line.split(',').map(|s| s.trim().to_string()).collect();
    parts.iter().map(|p| p.parse::<u64>().unwrap_or(0)).sum()
}

/// Same result, no allocation.
pub fn sum_streaming(line: &str) -> u64 {
    line.split(',').map(|s| s.trim().parse::<u64>().unwrap_or(0)).sum()
}

fn main() {
    let line = "1, 2, 3, 4";
    println!("{} {}", sum_collect(line), sum_streaming(line));
}

// benches/parsing.rs
use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use my_crate::{sum_collect, sum_streaming};
use std::hint::black_box;

fn bench_parsing(c: &mut Criterion) {
    let mut group = c.benchmark_group("sum_line");
    for n in [10, 1_000] {
        let line: String = (0..n).map(|i| i.to_string()).collect::<Vec<_>>().join(", ");
        group.bench_with_input(BenchmarkId::new("collect", n), &line, |b, line| b.iter(|| sum_collect(black_box(line))));
        group.bench_with_input(BenchmarkId::new("streaming", n), &line, |b, line| b.iter(|| sum_streaming(black_box(line))));
    }
    group.finish();
}

criterion_group!(benches, bench_parsing);
criterion_main!(benches);

#[derive(Debug)]
struct Invoice {
    customer: String,
    lines: Vec<(String, u32, u64)>,
}

fn render(inv: &Invoice) -> String {
    let mut out = format!("INVOICE for {}\n", inv.customer);
    let mut total = 0;
    for (item, qty, cents) in &inv.lines {
        let line_total = *qty as u64 * cents;
        total += line_total;
        out.push_str(&format!("{item:<10} {qty:>3} x {:>7.2} = {:>8.2}\n", *cents as f64 / 100.0, line_total as f64 / 100.0));
    }
    out.push_str(&format!("TOTAL {:>29.2}\n", total as f64 / 100.0));
    out
}

fn main() {}

#[cfg(test)]
mod tests {
    use super::*;

    fn sample() -> Invoice {
        Invoice { customer: "ACME".into(), lines: vec![("widget".into(), 3, 250), ("gadget".into(), 1, 1999)] }
    }

    #[test]
    fn invoice_text() {
        insta::assert_snapshot!(render(&sample()), @r"
        INVOICE for ACME
        widget       3 x    2.50 =     7.50
        gadget       1 x   19.99 =    19.99
        TOTAL                         27.49
        ");
    }

    #[test]
    fn invoice_debug() {
        insta::assert_debug_snapshot!(sample().lines[0], @r#"
        (
            "widget",
            3,
            250,
        )
        "#);
    }
}

use mockall::automock;

#[derive(Debug, PartialEq)]
pub struct Rate(pub f64);

#[automock]
pub trait RateProvider {
    fn rate(&self, from: &str, to: &str) -> Option<Rate>;
}

pub fn convert(provider: &dyn RateProvider, cents: u64, from: &str, to: &str) -> Result<u64, String> {
    if from == to {
        return Ok(cents); // must not call the provider
    }
    let Rate(r) = provider.rate(from, to).ok_or_else(|| format!("no rate {from}->{to}"))?;
    Ok((cents as f64 * r).round() as u64)
}

fn main() {}

#[cfg(test)]
mod tests {
    use super::*;
    use mockall::predicate::eq;

    #[test]
    fn converts_with_the_provider_rate() {
        let mut provider = MockRateProvider::new();
        provider.expect_rate().with(eq("EUR"), eq("USD")).times(1).returning(|_, _| Some(Rate(1.1)));
        assert_eq!(convert(&provider, 1000, "EUR", "USD"), Ok(1100));
    }

    #[test]
    fn same_currency_skips_the_provider() {
        let mut provider = MockRateProvider::new();
        provider.expect_rate().never();
        assert_eq!(convert(&provider, 1000, "EUR", "EUR"), Ok(1000));
    }

    #[test]
    fn missing_rate_is_an_error() {
        let mut provider = MockRateProvider::new();
        provider.expect_rate().returning(|_, _| None);
        assert_eq!(convert(&provider, 1000, "EUR", "JPY"), Err("no rate EUR->JPY".to_string()));
    }
}