running 1 test
Benchmarking Base64 auto
Benchmarking Base64 auto: Warming up for 3.0000 s
Benchmarking Base64 auto: Collecting 100 samples in estimated 5.0999 s (237k iterations)
Benchmarking Base64 auto: Analyzing
Base64 auto             time:   [21.400 us 21.481 us 21.573 us]
                        change: [-0.7790% +0.1404% +0.9293%] (p = 0.76 > 0.05)
                        No change in performance detected.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild

Benchmarking Base64 non-auto
Benchmarking Base64 non-auto: Warming up for 3.0000 s
Benchmarking Base64 non-auto: Collecting 100 samples in estimated 8.0379 s (5050 iterations)
Benchmarking Base64 non-auto: Analyzing
Base64 non-auto         time:   [1.6213 ms 1.6754 ms 1.7349 ms]
                        change: [-0.7231% +1.3173% +3.6913%] (p = 0.25 > 0.05)
                        No change in performance detected.
Found 16 outliers among 100 measurements (16.00%)
  5 (5.00%) high mild
  11 (11.00%) high severe

test test::tests::benchmark ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out



[code]
fn base64_auto(c: &mut Criterion) {
    let len = 1000;
    let ref_vec = {
        let mut tmp = Vec::<u8>::new();
        tmp.resize(len, 10);
        tmp
    };

    c.bench_function("Base64 auto",  move |b| b.iter(|| {
        let mut vec = BytesMut::with_capacity(len*10);
        let mut ret_vec = BytesMut::with_capacity(len*10);

        vec.resize(len*10, 10);
        ret_vec.resize(len*10, 0);

        let bytes_encoded = base64::encode_config_slice(&ref_vec, base64::STANDARD, &mut vec[..len*10]);

        vec.truncate(bytes_encoded);

        let bytes_decoded = base64::decode_config_bytes_auto(&mut vec, base64::STANDARD).unwrap();

        //vec.truncate() is done implicitly inside the custom decode function

        assert_eq!(bytes_decoded, len);
        assert_eq!(vec, ref_vec);
    }));
}


fn base64_non_auto(c: &mut Criterion) {
    let len = 1000;
    let ref_vec = {
        let mut tmp = Vec::<u8>::new();
        tmp.resize(len, 10);
        tmp
    };

    c.bench_function("Base64 non-auto",  move |b| b.iter(|| {
        let mut vec = Vec::<u8>::with_capacity(len*10);
        let mut ret_vec = Vec::<u8>::with_capacity(len*10);

        vec.resize(len*10, 10);
        ret_vec.resize(len*10, 0);

        let bytes_encoded = base64::encode_config_slice(&ref_vec, base64::STANDARD, &mut vec);

        vec.truncate(bytes_encoded);

        let bytes_decoded = base64::decode_config_slice(&vec, base64::STANDARD, &mut ret_vec[0..len*10]).unwrap();

        ret_vec.truncate(bytes_decoded);

        assert_eq!(bytes_decoded, len);
        assert_eq!(ret_vec, ref_vec);
    }));
}

///Main function
fn criterion_benchmark(c: &mut Criterion) {
    //c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
    base64_auto(c);
    base64_non_auto(c);
}