crush-cli 0.2.1

Command-line interface for the Crush compression library
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use std::hint::black_box;
use std::process::Command;
use std::time::Duration;

#[path = "bench_utils.rs"]
mod bench_utils;
use bench_utils::crush_binary;

/// Benchmark: CLI startup time with --version flag
/// Target: <50ms
fn bench_version_flag(c: &mut Criterion) {
    let binary = crush_binary();

    let mut group = c.benchmark_group("cli_startup");
    group.measurement_time(Duration::from_secs(10));
    group.sample_size(100);

    group.bench_function("version_flag", |b| {
        b.iter(|| {
            let output = Command::new(&binary)
                .arg("--version")
                .output()
                .expect("Failed to run crush --version");

            black_box(output)
        })
    });

    group.finish();
}

/// Benchmark: CLI startup time with invalid command (tests argument parsing)
/// Target: <50ms
fn bench_invalid_command(c: &mut Criterion) {
    let binary = crush_binary();

    let mut group = c.benchmark_group("cli_startup");
    group.measurement_time(Duration::from_secs(10));
    group.sample_size(100);

    group.bench_function("invalid_command", |b| {
        b.iter(|| {
            let output = Command::new(&binary)
                .arg("nonexistent-command")
                .output()
                .expect("Failed to run crush with invalid command");

            black_box(output)
        })
    });

    group.finish();
}

/// Benchmark: CLI startup time with no arguments (shows help)
/// Target: <50ms
fn bench_no_args(c: &mut Criterion) {
    let binary = crush_binary();

    let mut group = c.benchmark_group("cli_startup");
    group.measurement_time(Duration::from_secs(10));
    group.sample_size(100);

    group.bench_function("no_args", |b| {
        b.iter(|| {
            let output = Command::new(&binary)
                .output()
                .expect("Failed to run crush with no args");

            black_box(output)
        })
    });

    group.finish();
}

/// Benchmark: CLI startup with verbose flags
/// Measures the overhead of parsing multiple flags
fn bench_verbose_flags(c: &mut Criterion) {
    let binary = crush_binary();

    let mut group = c.benchmark_group("cli_startup");
    group.measurement_time(Duration::from_secs(10));
    group.sample_size(100);

    for verbosity in ["-v", "-vv", "-vvv"].iter() {
        group.bench_with_input(
            BenchmarkId::new("verbose", verbosity),
            verbosity,
            |b, &v| {
                b.iter(|| {
                    let output = Command::new(&binary)
                        .arg(v)
                        .arg("--version")
                        .output()
                        .expect("Failed to run crush with verbose flags");

                    black_box(output)
                })
            },
        );
    }

    group.finish();
}

criterion_group!(
    benches,
    bench_version_flag,
    bench_invalid_command,
    bench_no_args,
    bench_verbose_flags
);
criterion_main!(benches);