     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

    //! Enums denoting options for test execution.

    /// Whether to execute tests concurrently or not
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    pub enum Concurrent {
        Yes,
        No,
    }

    /// Number of times to run a benchmarked function
    #[derive(Clone, PartialEq, Eq)]
    pub enum BenchMode {
        Auto,
        Single,
    }

    /// Whether test is expected to panic or not
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub enum ShouldPanic {
        No,
        Yes,
        YesWithMessage(&'static str),
    }

    /// Whether should console output be colored or not
    #[derive(Copy, Clone, Debug)]
    pub enum ColorConfig {
        AutoColor,
        AlwaysColor,
        NeverColor,
    }

    /// Format of the test results output
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    pub enum OutputFormat {
        /// Verbose output
        Pretty,
        /// Quiet output
        Terse,
        /// JSON output
        Json,
    }

    /// Whether ignored test should be runned or not
    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
    pub enum RunIgnored {
        Yes,
        No,
        /// Run only ignored tests
        Only,
    }

    #[derive(Clone, Copy)]
    pub enum RunStrategy {
        /// Runs the test in the current process, and sends the result back over the
        /// supplied channel.
        InProcess,

        /// Spawns a subprocess to run the test, and sends the result back over the
        /// supplied channel. Requires `argv[0]` to exist and point to the binary
        /// that's currently running.
        SpawnPrimary,
    }

    /// Options for the test run defined by the caller (instead of CLI arguments).
    /// In case we want to add other options as well, just add them in this struct.
    #[derive(Copy, Clone, Debug)]
    pub struct Options {
        pub display_output: bool,
        pub panic_abort: bool,
    }

    impl Options {
        pub fn new() -> Options {
            Options {
                display_output: false,
                panic_abort: false,
            }
        }

        pub fn display_output(mut self, display_output: bool) -> Options {
            self.display_output = display_output;
            self
        }

        pub fn panic_abort(mut self, panic_abort: bool) -> Options {
            self.panic_abort = panic_abort;
            self
        }
    }