.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
lang/
alloc/
ast/
gen/
il/
layout/
lower/
manifest/
tests/
tests.rad
9.8 KiB
module/
parser/
resolver/
scanner/
sexpr/
alloc.rad
1.2 KiB
ast.rad
36.0 KiB
gen.rad
513 B
il.rad
48.5 KiB
layout.rad
6.9 KiB
lower.rad
487.6 KiB
manifest.rad
22.5 KiB
module.rad
17.8 KiB
package.rad
1.5 KiB
parser.rad
114.1 KiB
pretty.rad
103.6 KiB
resolver.rad
508.1 KiB
scanner.rad
19.3 KiB
sexpr.rad
7.1 KiB
strings.rad
3.3 KiB
types.rad
620 B
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/lang/manifest/tests.rad
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 | } |