axdevice 0.5.6

A reusable, OS-agnostic device abstraction layer designed for virtual machines.
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

use std::{fs, path::Path};

use axdevice::DeviceManagerError;
use axdevice_base::{DeviceError, RegistryError};

#[test]
fn crate_uses_typed_errors_without_errno_contracts() {
    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
    let manifest = fs::read_to_string(crate_dir.join("Cargo.toml")).unwrap();
    let dependency = ["ax", "errno"].join("-");
    let source_name = ["ax", "errno"].join("_");

    assert!(!manifest.contains(&dependency));
    assert_directory_excludes(&crate_dir.join("src"), &source_name);
}

#[test]
fn from_conversions_keep_device_and_registry_variants_matchable() {
    let device: DeviceManagerError = DeviceError::NotFound.into();
    let registry: DeviceManagerError = RegistryError::BusKindNotSupported {
        kind: axdevice_base::BusKind::Port,
        arch: axdevice_base::Arch::AArch64,
    }
    .into();

    assert!(matches!(
        device,
        DeviceManagerError::Device(DeviceError::NotFound)
    ));
    assert!(matches!(
        registry,
        DeviceManagerError::Registry(RegistryError::BusKindNotSupported { .. })
    ));
}

fn assert_directory_excludes(directory: &Path, forbidden: &str) {
    for entry in fs::read_dir(directory).unwrap() {
        let path = entry.unwrap().path();
        if path.is_dir() {
            assert_directory_excludes(&path, forbidden);
        } else if path.extension().is_some_and(|extension| extension == "rs") {
            let source = fs::read_to_string(&path).unwrap();
            assert!(!source.contains(forbidden), "{}", path.display());
        }
    }
}