dylint_testing 2.0.10

Utilities for testing Dylint libraries
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use crate::{example_target, example_targets, initialize, run_example_test, run_tests};
use std::{
    env::current_dir,
    path::{Path, PathBuf},
};

enum Target {
    SrcBase(PathBuf),
    Example(String),
    Examples,
}

pub struct Test {
    name: String,
    target: Target,
    rustc_flags: Vec<String>,
}

impl Test {
    #[must_use]
    pub fn src_base(name: &str, src_base: &Path) -> Self {
        Self::new(name, Target::SrcBase(src_base.to_owned()))
    }

    #[must_use]
    pub fn example(name: &str, example: &str) -> Self {
        Self::new(name, Target::Example(example.to_owned()))
    }

    #[must_use]
    pub fn examples(name: &str) -> Self {
        Self::new(name, Target::Examples)
    }

    pub fn rustc_flags(
        &mut self,
        rustc_flags: impl IntoIterator<Item = impl AsRef<str>>,
    ) -> &mut Self {
        self.rustc_flags
            .extend(rustc_flags.into_iter().map(|s| s.as_ref().to_owned()));
        self
    }

    pub fn run(&mut self) {
        self.run_immutable();
    }

    fn new(name: &str, target: Target) -> Self {
        Self {
            name: name.to_owned(),
            target,
            rustc_flags: Vec::new(),
        }
    }

    fn run_immutable(&self) {
        let driver = initialize(&self.name).unwrap();

        match &self.target {
            Target::SrcBase(src_base) => {
                run_tests(driver, src_base, self.rustc_flags.iter());
            }
            Target::Example(example) => {
                let metadata = dylint_internal::cargo::current_metadata().unwrap();
                let current_dir = current_dir().unwrap();
                let package =
                    dylint_internal::cargo::package_with_root(&metadata, &current_dir).unwrap();
                let target = example_target(&package, example).unwrap();

                run_example_test(
                    driver,
                    &metadata,
                    &package,
                    &target,
                    self.rustc_flags.iter(),
                )
                .unwrap();
            }
            Target::Examples => {
                let metadata = dylint_internal::cargo::current_metadata().unwrap();
                let current_dir = current_dir().unwrap();
                let package =
                    dylint_internal::cargo::package_with_root(&metadata, &current_dir).unwrap();
                let targets = example_targets(&package).unwrap();

                for target in targets {
                    run_example_test(
                        driver,
                        &metadata,
                        &package,
                        &target,
                        self.rustc_flags.iter(),
                    )
                    .unwrap();
                }
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    // smoelius: Verify that `rustc_flags` compiles when used as intended.
    #[allow(dead_code)]
    fn rustc_flags() {
        let _ = Test::src_base("name", &PathBuf::new()).rustc_flags(["--test"]);
    }
}