lib/std/lang/manifest/tests.rad 9.8 KiB raw
1
//! Tests for package manifests.
2
3
use std::mem;
4
use std::mem::heap;
5
use std::testing;
6
use std::lang::ast;
7
use std::lang::parser;
8
use std::lang::strings;
9
10
/// Syntax and result storage size.
11
constant ARENA_SIZE: u32 = 262144;
12
13
/// Syntax tree storage, reused by each test.
14
unsafe static SYNTAX: [u8; ARENA_SIZE] = undefined;
15
/// Result storage, reused by each test.
16
unsafe static RESULTS: [u8; ARENA_SIZE] = undefined;
17
/// Table storage for the string pool.
18
unsafe static STRING_TABLE: [*[u8]; strings::TABLE_SIZE] = undefined;
19
20
/// Read the manifest `text`, with fresh storage.
21
unsafe fn read(text: *[u8]) -> super::Package throws (super::Error) {
22
    let mut syntax = parser::newParser(ast::nodeArena(&mut SYNTAX[..]), strings::pool(
23
        &mut STRING_TABLE[..]
24
    ));
25
    return try super::read(&mut syntax, "test.manifest", text, heap::over(&mut RESULTS[..]));
26
}
27
28
/// Check that reading `text` fails with `expected`.
29
unsafe fn expectError(text: *[u8], expected: super::Error) throws (testing::TestError) {
30
    try read(text) catch failure {
31
        try testing::expect(failure == expected);
32
        return;
33
    };
34
    throw testing::TestError::Failed;
35
}
36
37
/// Check that two string lists are equal.
38
fn expectNames(actual: *[*[u8]], expected: *[*[u8]]) throws (testing::TestError) {
39
    try testing::expect(actual.len == expected.len);
40
    for name, i in expected {
41
        try testing::expect(mem::eq(actual[i], name));
42
    }
43
}
44
45
@test unsafe fn testReadPackage() throws (testing::TestError) {
46
    let package = try read(@embed("lang/manifest/tests/fixtures/kernel.manifest")) catch {
47
        throw testing::TestError::Failed;
48
    };
49
    try testing::expect(mem::eq(package.name, "kernel"));
50
    try testing::expect(mem::eq(package.version, "0.4.10"));
51
    try testing::expect(package.dependencies.len == 2);
52
    try testing::expect(mem::eq(package.dependencies[0].name, "std"));
53
    try testing::expect(mem::eq(package.dependencies[0].version, "0.1.0"));
54
    try testing::expect(mem::eq(package.dependencies[1].name, "util"));
55
    try testing::expect(mem::eq(package.dependencies[1].version, "2.3.4"));
56
    try expectNames(package.modules, &["abi", "abi::calls", "trap"]);
57
    try expectNames(package.tests, &["tests", "tests::abi", "abi::tests"]);
58
    try expectNames(package.assembly, &["kernel/boot.ras"]);
59
    let startup = package.startup else throw testing::TestError::Failed;
60
    try testing::expect(mem::eq(startup, "start.ras"));
61
    try expectNames(package.embed, &["data/table.bin"]);
62
}
63
64
@test unsafe fn testReadDefaults() throws (testing::TestError) {
65
    let package = try read("{ version: \"1.0.0\", name: \"app\", startup: nil }") catch {
66
        throw testing::TestError::Failed;
67
    };
68
    try testing::expect(mem::eq(package.name, "app"));
69
    try testing::expect(package.dependencies.len == 0);
70
    try testing::expect(package.modules.len == 0);
71
    try testing::expect(package.tests.len == 0);
72
    try testing::expect(package.assembly.len == 0);
73
    try testing::expect(package.startup == nil);
74
    try testing::expect(package.embed.len == 0);
75
}
76
77
/// Check parent-first order in both module lists.
78
@test unsafe fn testReadModulesInParentOrder() throws (testing::TestError) {
79
    let package = try read(@embed("lang/manifest/tests/fixtures/module_order.manifest")) catch {
80
        throw testing::TestError::Failed;
81
    };
82
    try expectNames(package.modules, &["a", "a::b", "a::b::c"]);
83
    try expectNames(package.tests, &["a::b::tests", "a::b::tests::c", "top"]);
84
}
85
86
@test unsafe fn testRejectFields() throws (testing::TestError) {
87
    let invalid = super::Error::Invalid;
88
    try expectError("Package { version: \"1.0.0\" }", invalid);
89
    try expectError("Package { name: \"app\" }", invalid);
90
    try expectError("Package { name: \"app\", version: \"1.0.0\", extra: [] }", invalid);
91
    try expectError("Package { name: \"app\", name: \"app\", version: \"1.0.0\" }", invalid);
92
    try expectError("Other { name: \"app\", version: \"1.0.0\" }", invalid);
93
    try expectError("Package { name: \"app\", version: \"1.0.0\", .. }", invalid);
94
    try expectError("[\"app\"]", invalid);
95
}
96
97
@test unsafe fn testRejectValues() throws (testing::TestError) {
98
    let invalid = super::Error::Invalid;
99
    try expectError("{ name: \"1app\", version: \"1.0.0\" }", invalid);
100
    try expectError("{ name: NAME, version: \"1.0.0\" }", invalid);
101
    try expectError("{ name: \"app\", version: \"1.0\" }", invalid);
102
    try expectError("{ name: \"app\", version: \"1.x.0\" }", invalid);
103
    try expectError("{ name: \"app\", version: \"1.0.0\", assembly: [\"../a.ras\"] }", invalid);
104
    try expectError("{ name: \"app\", version: \"1.0.0\", embed: [\"/a\"] }", invalid);
105
    try expectError("{ name: \"app\", version: \"1.0.0\", modules: [\"a::\"] }", invalid);
106
    try expectError("{ name: \"app\", version: \"1.0.0\", modules: [\"a/b\"] }", invalid);
107
    try expectError("{ name: \"app\", version: \"1.0.0\", modules: \"a\" }", invalid);
108
    try expectError(
109
        "{ name: \"app\", version: \"1.0.0\", dependencies: [{ name: \"std\" }] }", invalid
110
    );
111
    try expectError(
112
        "{ name: \"app\", version: \"1.0.0\", dependencies: [{ version: \"1.0.0\" }] }", invalid
113
    );
114
    try expectError(
115
        "{ name: \"app\", version: \"1.0.0\", dependencies: [{ name: \"std\", version: \"1\" }] }",
116
        invalid
117
    );
118
    try expectError(
119
        "{ name: \"app\", version: \"1.0.0\", dependencies: [Other { name: \"std\", version: \"1.0.0\" }] }",
120
        invalid
121
    );
122
    try expectError("{ name: \"app\", version: \"1.0.0\" } + 1", invalid);
123
    try expectError("{ name: \"app\", version: \"1.0.0\"", super::Error::Syntax);
124
}
125
126
@test unsafe fn testRejectDuplicates() throws (testing::TestError) {
127
    let invalid = super::Error::Invalid;
128
    try expectError(
129
        "{ name: \"app\", version: \"1.0.0\", dependencies: [{ name: \"std\", version: \"1.0.0\" }, { name: \"std\", version: \"2.0.0\" }] }",
130
        invalid
131
    );
132
    try expectError("{ name: \"app\", version: \"1.0.0\", modules: [\"a\", \"a\"] }", invalid);
133
    try expectError(
134
        "{ name: \"app\", version: \"1.0.0\", modules: [\"a\"], tests: [\"a\"] }", invalid
135
    );
136
}
137
138
@test unsafe fn testRejectMissingParents() throws (testing::TestError) {
139
    let invalid = super::Error::Invalid;
140
    try expectError("{ name: \"app\", version: \"1.0.0\", modules: [\"a::b\"] }", invalid);
141
    try expectError(
142
        "{ name: \"app\", version: \"1.0.0\", modules: [\"tests::a\"], tests: [\"tests\"] }",
143
        invalid
144
    );
145
    try expectError("{ name: \"app\", version: \"1.0.0\", tests: [\"a::tests\"] }", invalid);
146
}
147
148
@test unsafe fn testModulePath() throws (testing::TestError) {
149
    let arena = heap::over(&mut RESULTS[..]);
150
    let nested = try super::modulePath("mem::heap", arena) catch {
151
        throw testing::TestError::Failed;
152
    };
153
    try testing::expect(mem::eq(nested, "mem/heap"));
154
    let top = try super::modulePath("util", arena) catch {
155
        throw testing::TestError::Failed;
156
    };
157
    try testing::expect(mem::eq(top, "util"));
158
}
159
160
@test unsafe fn testFile() throws (testing::TestError) {
161
    let arena = heap::over(&mut RESULTS[..]);
162
    let cases: [[*[u8]; 3]; 4] = [
163
        ["lib/std",      "std", "lib/std/std.manifest"],
164
        [".",            "app", "app.manifest"],
165
        ["../lib/util/", "util", "../lib/util/util.manifest"],
166
        ["/srv/app",     "app", "/srv/app/app.manifest"],
167
    ];
168
    for item in &cases[..] {
169
        let path = try super::file(item[0], item[1], arena) catch {
170
            throw testing::TestError::Failed;
171
        };
172
        try testing::expect(mem::eq(path, item[2]));
173
    }
174
}
175
176
@test unsafe fn testLibraries() throws (testing::TestError) {
177
    let arena = heap::over(&mut RESULTS[..]);
178
    let nested = try super::libraries("compiler/radiance", &["extra"], arena) catch {
179
        throw testing::TestError::Failed;
180
    };
181
    try expectNames(nested, &["extra", "compiler/radiance/lib", "compiler/lib", "lib"]);
182
    let current = try super::libraries(".", &[], arena) catch {
183
        throw testing::TestError::Failed;
184
    };
185
    try expectNames(current, &["lib"]);
186
    let above = try super::libraries("../app", &[], arena) catch {
187
        throw testing::TestError::Failed;
188
    };
189
    try expectNames(above, &["../app/lib", "../lib"]);
190
    let absolute = try super::libraries("/srv/app", &[], arena) catch {
191
        throw testing::TestError::Failed;
192
    };
193
    try expectNames(absolute, &["/srv/app/lib", "/srv/lib", "/lib"]);
194
}
195
196
@test fn testCompatible() throws (testing::TestError) {
197
    assert not super::compatible("1.0.0", "18446744073709551617.0.0");
198
    assert super::compatible("1.18446744073709551615.0", "1.18446744073709551616.0");
199
    assert super::compatible("1.2.3", "1.2.3");
200
    assert super::compatible("1.2.3", "1.2.4");
201
    assert super::compatible("1.2.3", "1.10.0");
202
    assert not super::compatible("1.2.3", "1.2.2");
203
    assert not super::compatible("1.2.3", "1.1.9");
204
    assert not super::compatible("1.2.3", "2.0.0");
205
    assert super::compatible("0.1.0", "0.1.7");
206
    assert not super::compatible("0.1.0", "0.2.0");
207
    assert not super::compatible("0.1.2", "0.1.1");
208
}
209
210
@test unsafe fn testResolve() throws (testing::TestError) {
211
    let arena = heap::over(&mut RESULTS[..]);
212
    let cases: [[*[u8]; 3]; 7] = [
213
        ["kernel/kernel.manifest", "../lib/std.manifest", "lib/std.manifest"],
214
        ["kernel/kernel.manifest", "kernel/boot.ras", "kernel/kernel/boot.ras"],
215
        ["app.manifest",           "./util/../util.manifest", "util.manifest"],
216
        ["app.manifest",           "../x.manifest", "../x.manifest"],
217
        ["a/b.manifest",           "../../c", "../c"],
218
        ["/srv/a/b.manifest",      "../../../c", "/c"],
219
        ["a/b.manifest",           "/abs/c", "/abs/c"],
220
    ];
221
    for item in &cases[..] {
222
        let path = try super::resolve(item[0], item[1], arena) catch {
223
            throw testing::TestError::Failed;
224
        };
225
        try testing::expect(mem::eq(path, item[2]));
226
    }
227
}