axbuild 0.4.14

An OS build lib toolkit used by arceos
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

use super::*;
use crate::build::info::AxFeaturePrefixFamily;

#[test]
fn detects_axfeat_direct_dependency_via_metadata() {
    let workspace = temp_workspace("ax-feat-app", "ax-feat = \"0.1.0\"\n").unwrap();

    let metadata = metadata_for_manifest(&workspace.join("Cargo.toml"));
    let family = detect_ax_feature_prefix_family("ax-feat-app", &metadata).unwrap();

    assert_eq!(family, AxFeaturePrefixFamily::AxFeat);
}

#[test]
fn std_build_maps_arceos_features_to_ax_std_dependency() {
    let mut info = BuildInfo {
        features: vec![
            "ax-std".to_string(),
            "lockdep".to_string(),
            "ax-std/smp".to_string(),
        ],
        ..BuildInfo::default()
    };

    info.resolve_std_features();
    let mut envs = HashMap::new();
    pass_std_build_nested_features(
        &mut envs,
        &mut info.features,
        &[],
        &[
            "lockdep".to_string(),
            "smp".to_string(),
            "std-compat".to_string(),
        ],
    );

    assert_eq!(
        info.features,
        vec![
            "ax-std/lockdep".to_string(),
            "ax-std/smp".to_string(),
            "ax-std/std-compat".to_string()
        ]
    );
    assert!(envs.is_empty());
    assert!(!envs.values().any(|value| value.contains("arceos")));
    assert!(!info.features.contains(&"lockdep".to_string()));
}

#[test]
fn makefile_features_use_ax_std_dependency_for_std_build() {
    let mut info = BuildInfo {
        features: Vec::new(),
        ..BuildInfo::default()
    };

    apply_makefile_features_with_prefix_family(
        &mut info,
        "arceos-app",
        &[String::from("lockdep")],
        Err(anyhow::anyhow!("std test packages do not depend on ax-std")),
    );

    info.resolve_std_features();
    let mut envs = HashMap::new();
    pass_std_build_nested_features(
        &mut envs,
        &mut info.features,
        &[],
        &["lockdep".to_string(), "std-compat".to_string()],
    );

    assert_eq!(
        info.features,
        vec![
            "ax-std/lockdep".to_string(),
            "ax-std/std-compat".to_string()
        ]
    );
    assert!(envs.is_empty());
}

#[test]
fn retired_static_aarch64_platform_features_are_not_ax_hal_platforms() {
    let metadata = repo_metadata();

    for feature in [
        "ax-hal/aarch64-qemu-virt",
        "ax-hal/aarch64-raspi",
        "ax-hal/aarch64-bsta1000b",
        "ax-hal/aarch64-phytium-pi",
    ] {
        assert_eq!(ax_hal_platform_feature_name(feature, Some(&metadata)), None);
    }
}

#[test]
fn default_aarch64_platform_feature_falls_back_to_defplat() {
    let mut info = BuildInfo::default();

    info.resolve_features_with_prefix_family(
        "arceos-helloworld",
        "aarch64-unknown-none-softfloat",
        false,
        Ok(AxFeaturePrefixFamily::AxStd),
        None,
    );

    assert!(info.features.contains(&"ax-hal/defplat".to_string()));
    assert!(
        !info
            .features
            .contains(&"ax-hal/aarch64-qemu-virt".to_string())
    );
}