grpctestify 1.8.6

gRPC testing utility written in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

mod common;

use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
use std::hint::black_box;

const SINGLE_DOC: &str = r#"--- ENDPOINT ---
svc.Method
--- REQUEST ---
{"id": 1}
--- RESPONSE ---
{"status": "ok"}
"#;

fn bench_parse(c: &mut Criterion) {
    let mut group = c.benchmark_group("parser/parse_gctf");

    group.throughput(Throughput::Bytes(SINGLE_DOC.len() as u64));
    group.bench_function("single_doc", |b| {
        b.iter(|| {
            let doc = grpctestify::parser::parse_gctf_from_str(black_box(SINGLE_DOC), "bench.gctf")
                .expect("parse single doc");
            black_box(doc.document_count());
        });
    });

    for docs in [10usize, 100, 1000] {
        let source = common::generate_multi_doc_content(docs);
        group.throughput(Throughput::Bytes(source.len() as u64));
        group.bench_with_input(BenchmarkId::from_parameter(docs), &source, |b, input| {
            b.iter(|| {
                let doc = grpctestify::parser::parse_gctf_from_str(black_box(input), "bench.gctf")
                    .expect("parse multi doc");
                black_box(doc.document_count());
            });
        });
    }

    group.finish();
}

fn bench_validate(c: &mut Criterion) {
    let source = common::generate_multi_doc_content(100);
    let doc = grpctestify::parser::parse_gctf_from_str(&source, "bench.gctf").expect("parse");

    c.bench_function("parser/validate_document_diagnostics_chain_100", |b| {
        b.iter(|| {
            for d in doc.iter_chain() {
                let out = grpctestify::parser::validate_document_diagnostics(d);
                black_box(out.len());
            }
        });
    });
}

criterion_group!(parser_benches, bench_parse, bench_validate);
criterion_main!(parser_benches);