mobench-sdk 0.2.0

Rust SDK for mobile benchmarking with timing harness and Android/iOS builders
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

//! Characterizes the v0.1.43 editable/embedded template boundary.

use std::collections::BTreeSet;
use std::fs;
use std::path::{Path, PathBuf};

fn relative_files(root: &Path) -> BTreeSet<PathBuf> {
    fn walk(root: &Path, current: &Path, files: &mut BTreeSet<PathBuf>) {
        let mut entries = fs::read_dir(current)
            .unwrap_or_else(|error| panic!("failed to read {}: {error}", current.display()))
            .collect::<Result<Vec<_>, _>>()
            .unwrap_or_else(|error| panic!("failed to enumerate {}: {error}", current.display()));
        entries.sort_by_key(|entry| entry.path());
        for entry in entries {
            let path = entry.path();
            if path.is_dir() {
                walk(root, &path, files);
            } else if path.is_file() {
                files.insert(path.strip_prefix(root).expect("descendant").to_path_buf());
            }
        }
    }

    let mut files = BTreeSet::new();
    walk(root, root, &mut files);
    files
}

#[test]
fn template_mirrors_have_only_the_characterized_ios_header_drift() {
    let workspace = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
    let editable_root = workspace.join("templates");
    let embedded_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("templates");

    let editable_files = relative_files(&editable_root);
    let embedded_files = relative_files(&embedded_root);
    assert_eq!(
        editable_files, embedded_files,
        "v0.1.43 editable and embedded template file inventories drifted"
    );

    let mismatches = editable_files
        .iter()
        .filter(|relative| {
            fs::read(editable_root.join(relative)).expect("read editable template")
                != fs::read(embedded_root.join(relative)).expect("read embedded template")
        })
        .cloned()
        .collect::<BTreeSet<_>>();

    assert_eq!(
        mismatches,
        [PathBuf::from(
            "ios/BenchRunner/BenchRunner/BenchRunner-Bridging-Header.h.template",
        )]
        .into_iter()
        .collect(),
        "update the template ownership receipt when mirror drift changes"
    );
}

#[test]
fn web_templates_are_synchronized_byte_for_byte() {
    let workspace = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
    let editable_root = workspace.join("templates/web");
    let embedded_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("templates/web");

    let expected = [
        PathBuf::from("index.html"),
        PathBuf::from("runner.js"),
        PathBuf::from("worker.js"),
    ]
    .into_iter()
    .collect::<BTreeSet<_>>();
    assert_eq!(relative_files(&editable_root), expected);
    assert_eq!(relative_files(&embedded_root), expected);

    for relative in expected {
        assert_eq!(
            fs::read(editable_root.join(&relative)).expect("read editable web template"),
            fs::read(embedded_root.join(&relative)).expect("read embedded web template"),
            "web template mirror drifted: {}",
            relative.display()
        );
    }
}