isotarp 0.1.12

Identify which tests provide code coverage of which lines, uniquness, and redundancy
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};

pub type TestCoverageResult = (String, HashMap<String, HashSet<u64>>);

/// Representation of Tarpaulin's JSON output
#[derive(Debug, Deserialize, Serialize)]
pub struct TarpaulinReport {
    pub files: Vec<SourceFile>,
    pub coverage: f64,
    pub covered: usize,
    pub coverable: usize,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct SourceFile {
    pub path: Vec<String>,
    pub content: String,
    pub traces: Vec<Trace>,
    pub covered: usize,
    pub coverable: usize,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Trace {
    pub line: u64,
    pub stats: LineStat,
    pub address: HashSet<u64>,
    pub length: u64,
}

#[derive(Debug, Deserialize, Serialize)]
pub enum LineStat {
    Line(u64),
}

/// Analysis of a single test's coverage
#[derive(Debug, Serialize)]
pub struct TestCoverageAnalysis {
    pub total_covered_lines: u32,
    pub unique_covered_lines: u32,
    pub files: HashMap<String, FileCoverageAnalysis>,
}

/// Analysis of a file's coverage by a test
#[derive(Debug, Serialize)]
pub struct FileCoverageAnalysis {
    pub total_covered_lines: u32,
    pub unique_covered_lines: u32,
    pub unique_lines: Vec<u64>,
}

/// Complete analysis output
#[derive(Debug, Serialize)]
pub struct IsotarpAnalysis {
    pub package: String,
    pub tests: HashMap<String, TestCoverageAnalysis>,
}

/// Mode for managing target directories during test execution
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
pub enum TargetMode {
    /// Create a separate target directory for each test (more disk space, parallel execution)
    #[default]
    Per,
    /// Reuse a single target directory for all tests (less disk space, sequential execution)
    One,
}

impl std::fmt::Display for TargetMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TargetMode::Per => write!(f, "per"),
            TargetMode::One => write!(f, "one"),
        }
    }
}