Struct TestGenerator 

pub struct TestGenerator { /* private fields */ }

Test generator for creating test cases from CLI analysis

Implementations

impl TestGenerator

pub fn new(analysis: CliAnalysis, categories: Vec<TestCategory>) -> Self

Create a new test generator

pub fn with_config( analysis: CliAnalysis, categories: Vec<TestCategory>, config_path: Option<&Path>, ) -> Result<Self>

Create a new test generator with configuration file

pub fn generate(&self) -> Result<Vec<TestCase>>

Generate all test cases based on selected categories

Examples

use cli_testing_specialist::analyzer::CliParser;
use cli_testing_specialist::generator::TestGenerator;
use cli_testing_specialist::types::TestCategory;
use std::path::Path;

let parser = CliParser::new();
let analysis = parser.analyze(Path::new("/usr/bin/curl"))?;

let generator = TestGenerator::new(
    analysis,
    vec![TestCategory::Basic, TestCategory::Security, TestCategory::Help]
);

let tests = generator.generate()?;
println!("Generated {} test cases", tests.len());

// Count tests by category
let basic_tests = tests.iter()
    .filter(|t| t.category == TestCategory::Basic)
    .count();
println!("Basic tests: {}", basic_tests);

pub fn generate_parallel(&self) -> Result<Vec<TestCase>>

Generate tests in parallel using rayon

Automatically chooses optimal parallelization strategy based on workload size. For large CLI tools (10+ subcommands), this provides 2-3x speedup.

Examples

use cli_testing_specialist::analyzer::CliParser;
use cli_testing_specialist::generator::TestGenerator;
use cli_testing_specialist::types::TestCategory;
use std::path::Path;

let parser = CliParser::new();
let analysis = parser.analyze(Path::new("/usr/bin/kubectl"))?;

let generator = TestGenerator::new(
    analysis,
    vec![TestCategory::Basic, TestCategory::Security]
);

// Use parallel generation for large CLI tools
let tests = generator.generate_parallel()?;
println!("Generated {} tests in parallel", tests.len());

pub fn generate_with_strategy(&self) -> Result<Vec<TestCase>>

Generate tests with automatic strategy selection

This is the recommended method for test generation. It automatically chooses the optimal parallel processing strategy based on:

• Number of test categories
• CLI complexity (options and subcommands)
• Available CPU cores

Strategy Selection

• Sequential: Small workloads (<20 tests, 1 category)
• CategoryLevel: Medium workloads (20-100 tests, multiple categories)
• TestLevel: Large workloads (100+ tests, 4+ CPU cores)

Examples

let generator = TestGenerator::new(analysis, categories);
let tests = generator.generate_with_strategy()?;