cargo-darwin 0.3.0

Darwin mutates your code, if your code still passes check tests, then your code isn't enough tested.
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
78
79
80

use colored::Colorize;
use std::fmt::{Display, Formatter};

#[derive(Debug, PartialEq)]
pub(crate) enum MutationStatus {
    Success,
    Fail,
    Timeout,
    CompilationFailed,
}

impl Display for MutationStatus {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            MutationStatus::Success => write!(f, "Missing test, code base vulnerable to mutation"),
            MutationStatus::Fail => write!(f, "Mutation caught, code base robust to mutation"),
            MutationStatus::Timeout => write!(f, "Mutation causes an infinite loop, inconclusive"),
            MutationStatus::CompilationFailed => write!(f, "Mutation killed, unsustainable"),
        }
    }
}

#[derive(Debug, PartialEq)]
pub(crate) struct MutationReport {
    pub(crate) stdout: String,
    pub(crate) stderr: String,
    pub(crate) status: MutationStatus,
}

impl MutationReport {
    pub(crate) fn new(stdout: String, stderr: String, status: MutationStatus) -> Self {
        MutationReport {
            stdout,
            stderr,
            status,
        }
    }

    pub(crate) fn pretty(&self) -> String {
        match self.status {
            MutationStatus::Success => {
                // Tests pass, the mutation hasn't been caught, suspicion of missing test
                format!("{}", "[Missing]".yellow())
            }
            MutationStatus::Fail => {
                // Tests failed, the mutation has been caught
                format!("{}", "[OK]     ".green())
            }
            MutationStatus::Timeout => {
                // Mutation introduces infinite loop, inconclusive
                format!("{}", "[Timeout]".white())
            }
            MutationStatus::CompilationFailed => {
                // Mutation introduces non compilable project
                format!("{}", "[Killed] ".white())
            }
        }
    }

    pub(crate) fn simple(&self) -> String {
        match self.status {
            MutationStatus::Success => {
                // Tests pass, the mutation hasn't been caught, suspicion of missing test
                format!("{}", "[Missing]")
            }
            MutationStatus::Fail => {
                // Tests failed, the mutation has been caught
                format!("{}", "[OK]")
            }
            MutationStatus::Timeout => {
                // Mutation introduces infinite loop, inconclusive
                format!("{}", "[Timeout]")
            }
            MutationStatus::CompilationFailed => {
                // Mutation introduces non compilable project
                format!("{}", "[Killed]")
            }
        }
    }
}