wptreport 0.0.5

Tools for working with WPT reports
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

pub mod reports;
pub mod score;
pub mod summarize;

pub use reports::{score_summary, servo_test_scores, wpt_report};
pub use score::score_wpt_report;

#[rustfmt::skip]
pub trait ScorableReport {
    type TestResultIter<'b>: TestResultIter + 'b where Self: 'b;
    type TestIter<'a>: Iterator<Item = Self::TestResultIter<'a>> where Self: 'a;

    fn results(&self) -> Self::TestIter<'_>;
}

pub trait TestResultIter {
    fn name(&self) -> &str;
    fn subtest_counts(&self) -> SubtestCounts;
}

#[derive(Debug, Copy, Clone, Default)]
pub struct AreaScores {
    pub tests: SubtestCounts,
    pub subtests: SubtestCounts,
    // See: https://github.com/web-platform-tests/results-analysis/blob/0357bcf8973a6de5f544e1f82e50e7322805e214/interop-scoring/main.js#L250
    // This value represents the sum of the interop score for each individual test. But has not been divided by the number of tests.
    pub interop_score_sum: u64,
}

impl AreaScores {
    /// The WPT score percentage using the "interop" scoring methodology
    /// The value is represented as a number between 0 and 1000
    /// See: https://github.com/web-platform-tests/results-analysis/blob/0357bcf8973a6de5f544e1f82e50e7322805e214/interop-scoring/main.js#L250
    pub fn interop_score(&self) -> u16 {
        (self.interop_score_sum as f64 / self.tests.total as f64).floor() as u16
    }
}

#[derive(Debug, Copy, Clone, Default)]
pub struct SubtestCounts {
    pub pass: u32,
    pub total: u32,
}

impl SubtestCounts {
    pub fn all_passing(self) -> bool {
        self.pass == self.total
    }

    pub fn pass_fraction(self) -> f64 {
        if self.total == 0 {
            0.0
        } else {
            (self.pass as f64) / (self.total as f64)
        }
    }

    pub fn passes_per_1000(self) -> u16 {
        if self.total == 0 {
            0
        } else {
            ((self.pass as f64) / (self.total as f64) * 1000.0).floor() as u16
        }
    }
}