引言

cargo run和cargo test是Rust开发者每天使用频率最高的命令，但它们远不止"运行程序"和"跑测试"这么简单。深入理解这两个命令的工作机制、优化技巧和高级用法，是提升Rust开发效率的关键。💡

核心概念剖析

cargo run的工作流程

cargo run
# 实际执行步骤：
# 1. 解析Cargo.toml和Cargo.lock
# 2. 检查依赖是否需要更新
# 3. 编译项目（如果有变更）
# 4. 链接生成二进制文件
# 5. 执行二进制文件

cargo test的三层结构

// 1. 单元测试（模块内）
#[cfg(test)]
mod tests {
    #[test]
    fn unit_test() {}
}

// 2. 集成测试（tests/目录）
// tests/integration_test.rs

// 3. 文档测试（文档注释中）
/// ```
/// assert_eq!(2 + 2, 4);
/// ```

深度实践：构建高效的开发工作流

1. cargo run的高级用法

// src/main.rs
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    if args.len() > 1 {
        match args[1].as_str() {
            "server" => start_server(),
            "worker" => start_worker(),
            "migrate" => run_migration(),
            _ => println!("未知命令"),
        }
    } else {
        println!("用法: cargo run -- <command>");
    }
}

fn start_server() {
    println!("启动服务器...");
}

fn start_worker() {
    println!("启动工作进程...");
}

fn run_migration() {
    println!("执行数据库迁移...");
}

# 基础用法
cargo run

# 传递参数（-- 后面的参数传给程序）
cargo run -- server
cargo run -- --host 0.0.0.0 --port 8080

# 指定二进制目标（多bin项目）
cargo run --bin server
cargo run --bin worker

# 使用不同的profile
cargo run --release  # 优化编译
cargo run --profile production  # 自定义profile

# 指定features
cargo run --features "tls,metrics"
cargo run --no-default-features --features minimal

# 详细输出（调试编译问题）
cargo run -vv

# 离线模式（不更新依赖）
cargo run --offline

# 指定目标平台
cargo run --target x86_64-unknown-linux-musl

2. cargo test的深度应用

// src/lib.rs
/// 计算两数之和
/// 
/// # Examples
/// ```
/// use mylib::add;
/// assert_eq!(add(2, 3), 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("除数不能为零".to_string())
    } else {
        Ok(a / b)
    }
}

// ============================================
// 单元测试
// ============================================
#[cfg(test)]
mod tests {
    use super::*;
    
    // 基础测试
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
    
    // 测试panic
    #[test]
    #[should_panic]
    fn test_divide_by_zero() {
        divide(10, 0).unwrap();
    }
    
    // 测试错误消息
    #[test]
    #[should_panic(expected = "除数不能为零")]
    fn test_divide_by_zero_message() {
        divide(10, 0).unwrap();
    }
    
    // 返回Result的测试
    #[test]
    fn test_divide_result() -> Result<(), String> {
        let result = divide(10, 2)?;
        assert_eq!(result, 5);
        Ok(())
    }
    
    // 忽略慢速测试
    #[test]
    #[ignore]
    fn expensive_test() {
        // 耗时操作
        std::thread::sleep(std::time::Duration::from_secs(10));
    }
    
    // 条件编译的测试
    #[test]
    #[cfg(target_os = "linux")]
    fn linux_only_test() {
        // Linux特定测试
    }
    
    // Feature门控测试
    #[test]
    #[cfg(feature = "advanced")]
    fn advanced_feature_test() {
        // 高级功能测试
    }
}

// tests/integration_test.rs
use mylib::*;

// 集成测试：测试公开API
#[test]
fn integration_test_add() {
    assert_eq!(add(5, 7), 12);
}

// 测试多个模块交互
mod common;  // tests/common/mod.rs

#[test]
fn test_with_setup() {
    common::setup();
    // 执行测试
}

// 异步测试（需要tokio）
#[tokio::test]
async fn async_test() {
    let result = async_operation().await;
    assert_eq!(result, "success");
}

async fn async_operation() -> String {
    "success".to_string()
}

# ============================================
# cargo test高级用法
# ============================================

# 运行所有测试
cargo test

# 运行特定测试
cargo test test_add
cargo test divide  # 匹配所有包含"divide"的测试

# 运行特定模块的测试
cargo test tests::  # 单元测试
cargo test integration  # 集成测试

# 显示输出（默认captured）
cargo test -- --nocapture

# 显示详细信息
cargo test -- --show-output

# 单线程运行（避免并发问题）
cargo test -- --test-threads=1

# 运行被忽略的测试
cargo test -- --ignored

# 运行所有测试（包括ignored）
cargo test -- --include-ignored

# 仅编译测试（不运行）
cargo test --no-run

# 文档测试
cargo test --doc

# 指定测试二进制
cargo test --test integration_test

# 性能测试模式
cargo test --release

# 测试特定feature
cargo test --features "serde"
cargo test --all-features

# 详细输出（调试测试失败）
cargo test -vv

# 生成测试覆盖率（需要tarpaulin）
cargo install cargo-tarpaulin
cargo tarpaulin --out Html

3. 实战：构建智能测试脚本

#!/bin/bash
# test-smart.sh - 智能测试脚本

set -e

echo "🧪 开始智能测试流程..."

# 1. 快速检查（编译检查）
echo "📝 步骤1: 编译检查..."
cargo check --all-targets --all-features
echo "✅ 编译检查通过"

# 2. 运行单元测试（快速反馈）
echo "🔬 步骤2: 单元测试..."
cargo test --lib -- --nocapture
echo "✅ 单元测试通过"

# 3. 文档测试
echo "📚 步骤3: 文档测试..."
cargo test --doc
echo "✅ 文档测试通过"

# 4. 集成测试
echo "🔗 步骤4: 集成测试..."
cargo test --test '*' -- --test-threads=1
echo "✅ 集成测试通过"

# 5. 基准测试（可选）
if [ "$1" == "--bench" ]; then
    echo "⚡ 步骤5: 基准测试..."
    cargo bench
    echo "✅ 基准测试完成"
fi

# 6. 代码覆盖率
if [ "$1" == "--coverage" ]; then
    echo "📊 步骤6: 代码覆盖率..."
    cargo tarpaulin --out Html --output-dir coverage
    echo "✅ 覆盖率报告: coverage/index.html"
fi

echo "🎉 所有测试通过！"

4. 高级测试模式：属性测试

// 添加依赖
// [dev-dependencies]
// proptest = "1.4"

use proptest::prelude::*;

// 属性测试：自动生成测试用例
proptest! {
    #[test]
    fn test_add_commutative(a in 0..1000i32, b in 0..1000i32) {
        // 测试交换律
        assert_eq!(add(a, b), add(b, a));
    }
    
    #[test]
    fn test_add_associative(a in 0..100i32, b in 0..100i32, c in 0..100i32) {
        // 测试结合律
        assert_eq!(add(add(a, b), c), add(a, add(b, c)));
    }
}

// 自定义策略
fn string_strategy() -> impl Strategy<Value = String> {
    "[a-z]{1,10}"
}

proptest! {
    #[test]
    fn test_string_property(s in string_strategy()) {
        assert!(s.len() <= 10);
        assert!(s.chars().all(|c| c.is_lowercase()));
    }
}

5. 基准测试（Benchmark）

// benches/benchmark.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use mylib::add;

fn benchmark_add(c: &mut Criterion) {
    c.bench_function("add 2+3", |b| {
        b.iter(|| add(black_box(2), black_box(3)))
    });
}

fn benchmark_complex(c: &mut Criterion) {
    c.bench_function("complex operation", |b| {
        b.iter(|| {
            let mut sum = 0;
            for i in 0..1000 {
                sum += add(i, i);
            }
            sum
        })
    });
}

criterion_group!(benches, benchmark_add, benchmark_complex);
criterion_main!(benches);

# 运行基准测试
cargo bench

# 与baseline对比
cargo bench --bench benchmark -- --save-baseline before
# 修改代码后
cargo bench --bench benchmark -- --baseline before

# 生成性能报告
cargo bench -- --verbose

专业思考与优化策略 🤔

1. 编译缓存优化

# .cargo/config.toml
[build]
# 增量编译（开发模式）
incremental = true

# 并行编译
jobs = 8

# 使用sccache加速
rustc-wrapper = "sccache"

[profile.dev]
# 优化依赖但不优化本地代码
opt-level = 0
[profile.dev.package."*"]
opt-level = 2

# 清理缓存（解决奇怪的编译问题）
cargo clean

# 只清理target目录
rm -rf target

# 更新依赖
cargo update

# 查看编译时间
cargo build --timings

2. 测试组织策略

// tests/common/mod.rs - 共享测试工具
pub fn setup() {
    // 初始化测试环境
}

pub fn teardown() {
    // 清理测试环境
}

pub struct TestFixture {
    // 测试数据
}

impl TestFixture {
    pub fn new() -> Self {
        Self { }
    }
}

// tests/integration_test.rs
mod common;

#[test]
fn test_with_fixture() {
    let fixture = common::TestFixture::new();
    // 使用fixture
}

3. CI/CD集成

# .github/workflows/test.yml
name: Test

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Cache cargo
        uses: actions/cache@v3
        with:
          path: |
            ~/.cargo/bin/
            ~/.cargo/registry/index/
            ~/.cargo/registry/cache/
            ~/.cargo/git/db/
            target/
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
      
      - name: Run tests
        run: |
          cargo test --verbose --all-features
          cargo test --doc
      
      - name: Run ignored tests
        run: cargo test -- --ignored
      
      - name: Generate coverage
        run: |
          cargo install cargo-tarpaulin
          cargo tarpaulin --out Xml
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3

4. 性能对比分析

# 开发模式 vs 发布模式
time cargo run  # ~50ms启动
time cargo run --release  # ~10ms启动（快5倍）

# 测试性能
time cargo test  # ~2s（增量编译）
time cargo test --release  # ~5s（更慢但测试更准确）

# 建议：
# - 开发时用dev模式快速迭代
# - CI中用release模式确保性能
# - 性能测试必须用--release

实战技巧集锦 ✨

1. 快速反馈循环

# 使用cargo-watch自动运行
cargo install cargo-watch

# 代码变更时自动测试
cargo watch -x test

# 代码变更时自动运行
cargo watch -x run

# 组合命令
cargo watch -x check -x test -x run

2. 调试技巧

// 使用dbg!宏
fn debug_example(x: i32) -> i32 {
    dbg!(x);  // 打印: [src/main.rs:10] x = 5
    let result = x * 2;
    dbg!(result);  // 打印: [src/main.rs:12] result = 10
    result
}

#[test]
fn test_with_debug() {
    std::env::set_var("RUST_BACKTRACE", "1");
    debug_example(5);
}

# 使用gdb/lldb调试
cargo build
rust-gdb target/debug/myprogram

# 使用VS Code调试配置
# .vscode/launch.json
{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug",
      "cargo": {
        "args": ["build", "--bin=myprogram"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

3. 测试隔离

use std::sync::Mutex;
use lazy_static::lazy_static;

// 全局锁确保测试串行执行
lazy_static! {
    static ref SERIAL_TEST: Mutex<()> = Mutex::new(());
}

#[test]
fn test_needs_isolation() {
    let _guard = SERIAL_TEST.lock().unwrap();
    // 测试逻辑
}

最佳实践清单 📋

1. 日常开发

   • 使用cargo check快速检查
   • cargo test频繁运行
   • cargo run --release性能测试

2. 测试策略

   • 单元测试覆盖核心逻辑
   • 集成测试验证API
   • 文档测试保证示例正确

3. 性能优化

   • 开发用dev profile
   • 发布用release profile
   • 基准测试用criterion

4. CI/CD

   • 所有feature组合测试
   • 多平台测试
   • 代码覆盖率检查

结语

cargo run和cargo test是Rust开发的日常工具，但掌握其深层机制和高级用法，能大幅提升开发效率。从增量编译优化到智能测试策略，从CI集成到性能基准测试，这些技能是构建高质量Rust项目的基石！🚀