postject_sys 0.1.5

Unofficial bindings for postject
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
#![cfg(test)]

use bindgen::Builder;
use std::{
    fs,
    path::{Path, PathBuf},
};

struct OnDiskBindings {
    path: PathBuf,
    binding_builder: Builder,
}
impl OnDiskBindings {
    fn full_path(&self) -> PathBuf {
        Path::new(env!("CARGO_MANIFEST_DIR")).join(&self.path)
    }
    fn source(&self) -> String {
        const TARGETS: &[&str] = &[
            "x86_64-unkownn-linux-gnu",
            "x86_64-pc-windows-gnu",
            "x86_64-pc-windows-msvc",
            "i686-pc-windows-gnu",
            "i686-pc-windows-msvc",
            "x86_64-apple-darwin",
            "arm64-apple-darwin",
            "x86_64-apple-ios",
            "arm64-apple-ios",
        ];
        let mut sources = TARGETS.iter().copied().map(|target| {
            let source = self
                .binding_builder
                .clone()
                .clang_args([&format!("--target={}", target)])
                .generate()
                .unwrap()
                .to_string();
            (target, source)
        });
        let baseline = sources.next().unwrap();
        for (target, source) in sources {
            pretty_assertions::assert_str_eq!(
                &baseline.1,
                &source,
                "bindings are different between target {} and {}",
                baseline.0,
                target
            );
        }
        return baseline.1;
    }
    fn write(&self) {
        fs::write(self.full_path(), self.source()).unwrap();
    }
    fn assert(&self) {
        let mut actual = fs::read_to_string(self.full_path()).unwrap();

        let mut expected = self.source();
        normalize_source(&mut actual);
        normalize_source(&mut expected);
        pretty_assertions::assert_str_eq!(actual, expected);
    }
}

fn normalize_source(source: &mut String) {
    let lines: Vec<&str> = source
        .lines() //  Git on Windows might insert CR at line endings. Ignore differences between LF and CRLF.
        .skip_while(|line| line.starts_with("/*") || line.starts_with(" *")) // Remove header comments
        .collect();
    *source = lines.join("\n");
}

fn postjector_bindings() -> OnDiskBindings {
    OnDiskBindings {
        binding_builder: bindgen::builder()
            .formatter(bindgen::Formatter::Prettyplease)
            .header(concat!(
                env!("CARGO_MANIFEST_DIR"),
                "/cmake/src/postjector.h"
            ))
            .prepend_enum_name(false)
            .allowlist_var("POSTJECTOR_.*")
            .allowlist_function("postjector_.*")
            .raw_line("#![allow(non_camel_case_types)]")
            .layout_tests(false),
        path: PathBuf::from("src/postjector.rs"),
    }
}

#[test]
fn test_postjector_bindings() {
    postjector_bindings().assert()
}

#[test]
#[ignore]
fn write_postjector_bindings() {
    postjector_bindings().write()
}

fn postjectee_bindings() -> OnDiskBindings {
    OnDiskBindings {
        binding_builder: bindgen::builder()
            .formatter(bindgen::Formatter::Prettyplease)
            .header("src/postjectee.h")
            .allowlist_function("postjectee_.*")
            .layout_tests(false),
        path: PathBuf::from("src/postjectee.rs"),
    }
}
#[test]
fn test_postjectee_bindings() {
    postjectee_bindings().assert()
}

#[test]
#[ignore]
fn write_postjectee_bindings() {
    postjectee_bindings().write()
}