dowel_examples
Results of the suite that checks dowel from the outside. What each check fixes is in the README of its project; why some are left failing is in docs/10-findings.md.
dowel · checked against 7512e7639fc7 · dowel_examples · dowel-ref · docs/10-findings.md
Latest run
PASSED — 1867 checks: 1860 passed, 0 failed, 7 known, 0 fixed
316882ed4e11 2026-09-02T16:25:11Z on main
Checks
Every check this run made, by project. Each project links to its directory in the repository; README states what that project fixes.
ok projects/01-minimal — 10 checks (10 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | hello: check passes |
| passed | hello: build passes |
| passed | hello: a second build runs nothing, across backends too |
| passed | the binary runs and prints hello |
| passed | the direct executor builds from scratch in 2 actions (1 compile, 1 link) |
| passed | the direct executor produces a working binary too |
| passed | release builds too |
| passed | debug and release get separate build directories |
| passed | nothing unexpected is written next to the manifest |
| passed | test succeeds when the package declares no test target |
ok projects/02-config — 34 checks (34 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | app: check passes |
| passed | app: build passes |
| passed | app: a second build runs nothing, across backends too |
| passed | debug: the arms chosen by match reach the compiler |
| passed | release builds too |
| passed | release: the public defines of a dependency switch as well |
| passed | each configuration gets its own build directory |
| passed | the default features can be turned off |
| passed | dropping when feature.trace drops the define with it |
| passed | enabled features appear in the build directory identifier |
| passed | the specialized defines reach the arguments of app |
| passed | the public defines of a dependency reach app |
| passed | private flags of a dependency never reach a dependent |
| passed | private defines of a dependency never reach a dependent |
| passed | private includes of a dependency never reach a dependent |
| passed | private flags still apply to the target's own compilation |
| passed | private includes still apply to the target's own compilation |
| passed | compile_commands.json carries the specialized defines |
| passed | probe: check passes |
| passed | probe: test passes |
| passed | probe: test passes in release too |
| passed | or joins two comparisons on the same key |
| passed | not inverts one, which is how everywhere-except is written |
| passed | and joins a feature with a negated one |
| passed | and parentheses group across two different keys |
| passed | a predicate that cannot hold contributes nothing |
| passed | raising a feature drops the conjunction that excluded it |
| passed | while the disjunction still holds, which is not > and > or |
| passed | and with neither term it holds no longer |
| passed | a term naming the configuration drops with it |
| passed | while the terms that do not name it stay |
| passed | a misspelled value is refused inside: not target.os == "windwos" |
| passed | a misspelled value is refused inside: target.os == "linux" or target.os == "windwos" |
| passed | a misspelled value is refused inside: target.os == "windwos" and cfg.opt == "debug" |
ok projects/03-features — 17 checks (17 passed, 0 failed, 0 known, 0 fixed)
README · app · json · missing-optional · undeclared · xml
| state | check |
|---|---|
| passed | app: check passes |
| passed | app: build passes |
| passed | app: a second build runs nothing, across backends too |
| passed | the default features bring the json edge in |
| passed | graph shows the json edge |
| passed | json and xml can both be enabled |
| passed | both edges appear |
| passed | the default features can be turned off |
| passed | when the edge goes, neither the public defines nor the headers arrive |
| passed | when the edge goes, the archive is not built either |
| passed | a dependency behind a disabled feature is absent from the graph |
| passed | a disabled optional dependency need not exist on disk |
| passed | an undeclared feature passed to --features is rejected |
| passed | an undeclared feature referenced from dowel.build is rejected |
| passed | an undeclared feature gets a suggestion |
| passed | json: builds on its own |
| passed | xml: builds on its own |
ok projects/04-diagnostics — 94 checks (94 passed, 0 failed, 0 known, 0 fixed)
README · cases/abi-mismatch/app · cases/abi-mismatch/lib · cases/dependency-cycle · cases/duplicate-target · cases/empty-glob · cases/incomplete-runner · cases/invalid-source · cases/merge-conflict/app · cases/merge-conflict/lib · cases/missing-field · cases/missing-manifest · cases/missing-toolchain · cases/non-exhaustive-match · cases/type-mismatch · cases/undeclared-dependency · cases/unknown-cfg-key · cases/unknown-feature · cases/unknown-function · cases/unknown-kind · cases/unknown-property · cases/unknown-target · cases/unresolved-path
| state | check |
|---|---|
| passed | check reports unknown-property |
| passed | check exits non-zero on unknown-property |
| passed | check reports unknown-kind |
| passed | check exits non-zero on unknown-kind |
| passed | check reports unknown-function |
| passed | check exits non-zero on unknown-function |
| passed | check reports unknown-cfg-key |
| passed | check exits non-zero on unknown-cfg-key |
| passed | check reports unknown-feature |
| passed | check exits non-zero on unknown-feature |
| passed | check reports non-exhaustive-match |
| passed | check exits non-zero on non-exhaustive-match |
| passed | check reports type-mismatch |
| passed | check exits non-zero on type-mismatch |
| passed | check reports undeclared-dependency |
| passed | check exits non-zero on undeclared-dependency |
| passed | check reports unknown-target |
| passed | check exits non-zero on unknown-target |
| passed | check reports duplicate-target |
| passed | check exits non-zero on duplicate-target |
| passed | check reports dependency-cycle |
| passed | check exits non-zero on dependency-cycle |
| passed | check reports missing-manifest |
| passed | check exits non-zero on missing-manifest |
| passed | check reports missing-toolchain |
| passed | check exits non-zero on missing-toolchain |
| passed | check reports invalid-source |
| passed | check exits non-zero on invalid-source |
| passed | check reports unresolved-path |
| passed | check exits non-zero on unresolved-path |
| passed | check reports incomplete-runner |
| passed | check exits non-zero on incomplete-runner |
| passed | check reports missing-field |
| passed | check exits non-zero on missing-field |
| passed | check reports merge-conflict |
| passed | check exits non-zero on merge-conflict |
| passed | check reports abi-mismatch |
| passed | check exits non-zero on abi-mismatch |
| passed | check reports empty-glob |
| passed | build reports invalid-source as well |
| passed | build reports unresolved-path as well |
| passed | build reports empty-glob as well |
| passed | build exits non-zero on invalid-source |
| passed | build exits non-zero on unresolved-path |
| passed | a missing toolchain never reaches the shell |
| passed | unknown-property points at the offending source |
| passed | unknown-kind points at the offending source |
| passed | unknown-function points at the offending source |
| passed | unknown-cfg-key points at the offending source |
| passed | unknown-feature points at the offending source |
| passed | non-exhaustive-match points at the offending source |
| passed | type-mismatch points at the offending source |
| passed | undeclared-dependency points at the offending source |
| passed | unknown-target points at the offending source |
| passed | duplicate-target points at the offending source |
| passed | dependency-cycle points at the offending source |
| passed | missing-manifest points at the offending source |
| passed | missing-toolchain points at the offending source |
| passed | invalid-source points at the offending source |
| passed | unresolved-path points at the offending source |
| passed | incomplete-runner points at the offending source |
| passed | missing-field points at the offending source |
| passed | merge-conflict carries the location of both values |
| passed | merge-conflict renders the dependent side of the conflict too |
| passed | abi-mismatch carries the location of both values |
| passed | abi-mismatch renders the dependent side of the conflict too |
| passed | unknown-property carries a suggestion |
| passed | the manifest still passes check after applying the suggestion |
| passed | applying the suggestion keeps the value intact |
| passed | duplicate-target carries the location of both declarations |
| passed | naming which of the two came first, so the later one is the one to rename |
| passed | and why the name has to be unique, naming the object directory that keys on it |
| passed | and the suggestion offers a spelling that differs from both |
| passed | renaming one of them makes the same tree build |
| passed | with the library's public include directory reaching the sources that need it |
| passed | check refuses a target name |
| passed | and says that it checks everything |
| passed | a key outside the vocabulary is refused |
| passed | saying the vocabulary is closed, rather than that this name is merely unrecognised |
| passed | listing what that namespace does accept |
| passed | and where a project's own axis belongs, spelled with the name that was written |
| passed | the schema says the configuration vocabulary is closed, as the decision did |
| passed | a component outside the vocabulary is refused |
| passed | listing the components abi does accept |
| passed | and saying that this vocabulary is closed too |
| passed | and offering the component that was probably meant |
| passed | a value outside a component's domain is refused |
| passed | and the domain is listed |
| passed | a label made of known components is accepted |
| passed | a label written as one word is still accepted |
| passed | the configuration vocabulary carries the runtime axis the triple names |
| passed | with a domain, as every key in a closed vocabulary has |
| passed | and says how the vocabulary grows, which is what makes it dependable |
| passed | while the vocabulary it lists is the one the diagnostic enforces |
ok projects/05-incremental — 49 checks (49 passed, 0 failed, 0 known, 0 fixed)
README · app · core · crossing
| state | check |
|---|---|
| passed | app: check passes |
| passed | a first build runs every action (3 compiles, 1 archive, 1 link) |
| passed | the binary runs |
| passed | a second build runs nothing |
| passed | editing one source rebuilds it and everything downstream |
| passed | the edited unit is recompiled |
| passed | the other unit of the same target is not |
| passed | a dependent's own sources are not recompiled |
| passed | the archive is rebuilt |
| passed | the dependent is relinked |
| passed | editing a dependent's source touches nothing in the dependency |
| passed | the dependency's archive is left alone |
| passed | editing a private header rebuilds through the depfile |
| passed | the unit that includes the private header is recompiled |
| passed | a unit of the same target that does not include it is not |
| passed | a private header never reaches a dependent |
| passed | editing a public header rebuilds every dependent unit |
| passed | the dependency's own units are recompiled |
| passed | both of them |
| passed | and the dependent's unit as well |
| passed | while the dependency's own test is not built by its consumer at all |
| passed | touching a source without changing it still rebuilds (mtime judgement) |
| passed | touching the manifest without changing it rebuilds nothing |
| passed | adding only a comment to the manifest rebuilds nothing |
| passed | adding a flag recompiles the target it applies to |
| passed | the flag reaches the compile action |
| passed | and no further than the target that declares it |
| passed | adding a source compiles only the new one |
| passed | the new unit is compiled |
| passed | the existing units are not |
| passed | removing a source rebuilds the archive without compiling anything |
| passed | no compile action runs when only a source disappeared |
| passed | the first release build runs every action |
| passed | switching back to debug rebuilds nothing |
| passed | switching to release again rebuilds nothing |
| passed | core: both tests pass |
| passed | editing the public header reaches the library's own test |
| passed | and its own units, from the package that declares them |
| passed | test exits non-zero when a test fails |
| passed | the summary counts both outcomes |
| passed | --failed reruns only what failed last time |
| passed | --failed leaves the passing test alone |
| passed | the repaired test passes under --failed |
| passed | --failed says so when nothing failed last time |
| passed | a full run passes again |
| passed | a header edit is seen after building with ninja then direct |
| passed | a header edit is seen after building with direct then ninja |
| passed | a header edit is seen after building with ninja then ninja |
| passed | a header edit is seen after building with direct then direct |
ok projects/06-runner — 40 checks (40 passed, 0 failed, 0 known, 0 fixed)
README · crossed · plain · transferred
| state | check |
|---|---|
| passed | the host triple needs no runner |
| passed | running for another triple without a runner is refused |
| passed | the refusal carries the missing-runner code |
| passed | the refusal happens before the artifact is started |
| passed | building for another triple still works |
| passed | a declared runner lets the tests run for another triple |
| passed | the runner receives its declared args then the artifact |
| passed | the runner starts in the package root |
| passed | the build directory is per target triple |
| passed | a failing test still fails when it runs through a runner |
| passed | the exit status passes through the runner unchanged |
| passed | a runner that transfers the artifact works |
| passed | transfer gets the local path and the destination appended |
| passed | host prefixes the destination as ADR-0008 specifies |
| passed | the launch command gets the remote path, not the local one |
| passed | the artifact really arrives at the destination |
| passed | the manifest carries no placeholder for the transferred path |
| passed | the first test run transfers the artifact |
| passed | which really is one transfer |
| passed | an unchanged tree runs the tests again |
| passed | and sends nothing the second time |
| passed | changing the source and testing again works |
| passed | a changed artifact is sent again |
| passed | what was sent is recorded in the build directory |
| passed | testing after the record is gone works |
| passed | removing the record makes the next run send again |
| passed | a run whose launcher does not exist fails |
| passed | and is reported as a launch that never happened |
| passed | and the run after it works |
| passed | a run that could not start drops the record, so the next one sends again |
| passed | a run whose artifact vanished from the target fails |
| passed | the run that noticed does not itself re-send |
| passed | and the run after it passes |
| passed | a machine that lost the artifact recovers on the run after the one that noticed |
| passed | so the artifact is back on the target machine, with nothing touched by hand |
| passed | a test that keeps failing still fails |
| passed | and a failing run pays exactly one transfer, that being the price |
| passed | a passing run writes the record back |
| passed | so the run after it skips again |
| passed | which is the skip returning once the tree is healthy |
ok projects/07-robustness — 145 checks (145 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | array-missing-comma does not abort dowel |
| passed | array-missing-comma is refused |
| passed | array-missing-comma is refused with a source location |
| passed | array-missing-comma is answered within the budget |
| passed | cmake-syntax does not abort dowel |
| passed | cmake-syntax is refused |
| passed | cmake-syntax is refused with a source location |
| passed | cmake-syntax is answered within the budget |
| passed | json-object does not abort dowel |
| passed | json-object is refused |
| passed | json-object is refused with a source location |
| passed | json-object is answered within the budget |
| passed | key-with-space does not abort dowel |
| passed | key-with-space is refused |
| passed | key-with-space is refused with a source location |
| passed | key-with-space is answered within the budget |
| passed | match-missing-comma does not abort dowel |
| passed | match-missing-comma is refused |
| passed | match-missing-comma is refused with a source location |
| passed | match-missing-comma is answered within the budget |
| passed | missing-equals does not abort dowel |
| passed | missing-equals is refused |
| passed | missing-equals is refused with a source location |
| passed | missing-equals is answered within the budget |
| passed | missing-value does not abort dowel |
| passed | missing-value is refused |
| passed | missing-value is refused with a source location |
| passed | missing-value is answered within the budget |
| passed | semicolon does not abort dowel |
| passed | semicolon is refused |
| passed | semicolon is refused with a source location |
| passed | semicolon is answered within the budget |
| passed | smart-quotes does not abort dowel |
| passed | smart-quotes is refused |
| passed | smart-quotes is refused with a source location |
| passed | smart-quotes is answered within the budget |
| passed | stray-brace does not abort dowel |
| passed | stray-brace is refused |
| passed | stray-brace is refused with a source location |
| passed | stray-brace is answered within the budget |
| passed | two-headers-one-line does not abort dowel |
| passed | two-headers-one-line is refused |
| passed | two-headers-one-line is refused with a source location |
| passed | two-headers-one-line is answered within the budget |
| passed | unclosed-block-comment does not abort dowel |
| passed | unclosed-block-comment is refused |
| passed | unclosed-block-comment is refused with a source location |
| passed | unclosed-block-comment is answered within the budget |
| passed | unclosed-bracket does not abort dowel |
| passed | unclosed-bracket is refused |
| passed | unclosed-bracket is refused with a source location |
| passed | unclosed-bracket is answered within the budget |
| passed | unclosed-header does not abort dowel |
| passed | unclosed-header is refused |
| passed | unclosed-header is refused with a source location |
| passed | unclosed-header is answered within the budget |
| passed | unclosed-inline-table does not abort dowel |
| passed | unclosed-inline-table is refused |
| passed | unclosed-inline-table is refused with a source location |
| passed | unclosed-inline-table is answered within the budget |
| passed | unclosed-paren does not abort dowel |
| passed | unclosed-paren is refused |
| passed | unclosed-paren is refused with a source location |
| passed | unclosed-paren is answered within the budget |
| passed | unterminated-string does not abort dowel |
| passed | unterminated-string is refused |
| passed | unterminated-string is refused with a source location |
| passed | unterminated-string is answered within the budget |
| passed | wrong-arrow does not abort dowel |
| passed | wrong-arrow is refused |
| passed | wrong-arrow is refused with a source location |
| passed | wrong-arrow is answered within the budget |
| passed | yaml-colon does not abort dowel |
| passed | yaml-colon is refused |
| passed | yaml-colon is refused with a source location |
| passed | yaml-colon is answered within the budget |
| passed | ok-block-comment does not abort dowel |
| passed | ok-block-comment is accepted |
| passed | ok-line-comment does not abort dowel |
| passed | ok-line-comment is accepted |
| passed | ok-single-quotes does not abort dowel |
| passed | ok-single-quotes is accepted |
| passed | ok-tab-indent does not abort dowel |
| passed | ok-tab-indent is accepted |
| passed | ok-trailing-comma does not abort dowel |
| passed | ok-trailing-comma is accepted |
| passed | CRLF line endings does not abort dowel |
| passed | CRLF line endings is accepted |
| passed | a UTF-8 BOM on dowel.build does not abort dowel |
| passed | a UTF-8 BOM on dowel.build is accepted |
| passed | a UTF-8 BOM on dowel.toml does not abort dowel |
| passed | a UTF-8 BOM on dowel.toml is accepted |
| passed | a BOM in the middle of a line does not abort dowel |
| passed | a BOM in the middle of a line is refused |
| passed | a BOM in the middle of a line is refused with a source location |
| passed | invalid UTF-8 bytes does not abort dowel |
| passed | invalid UTF-8 bytes is refused |
| passed | invalid UTF-8 bytes is refused with a source location |
| passed | a NUL byte does not abort dowel |
| passed | a NUL byte is refused |
| passed | a NUL byte is refused with a source location |
| passed | a 200k element list does not abort dowel |
| passed | a 200k element list is refused |
| passed | a 200k element list is refused with a source location |
| passed | a 200k element list is answered within the budget |
| passed | a 10MB string literal does not abort dowel |
| passed | a 10MB string literal is refused |
| passed | a 10MB string literal is refused with a source location |
| passed | a 10MB string literal is answered within the budget |
| passed | 200k comment lines does not abort dowel |
| passed | 200k comment lines is accepted |
| passed | 200k comment lines is answered within the budget |
| passed | 100k nested arrays does not abort dowel |
| passed | 100k nested arrays is refused |
| passed | 100k nested arrays is refused with a source location |
| passed | 100k nested arrays is answered within the budget |
| passed | 100k nested arrays is refused as nesting-too-deep |
| passed | 100k nested inline tables does not abort dowel |
| passed | 100k nested inline tables is refused |
| passed | 100k nested inline tables is refused with a source location |
| passed | 100k nested inline tables is answered within the budget |
| passed | 100k nested inline tables is refused as nesting-too-deep |
| passed | 50k nested calls does not abort dowel |
| passed | 50k nested calls is refused |
| passed | 50k nested calls is refused with a source location |
| passed | 50k nested calls is answered within the budget |
| passed | 50k nested calls is refused as nesting-too-deep |
| passed | 2k nested inline tables does not abort dowel |
| passed | 2k nested inline tables is answered within the budget |
| passed | nesting 63 deep is accepted |
| passed | nesting 100 deep is refused |
| passed | nesting 100 deep is refused with a source location |
| passed | --max-nesting raises the limit |
| passed | --max-nesting can lower the limit too |
| passed | --max-nesting=0 is refused as a usage error |
| passed | --max-nesting=513 is refused as a usage error |
| passed | --max-nesting=abc is refused as a usage error |
| passed | --max-nesting=-1 is refused as a usage error |
| passed | dowel.build being a directory does not abort dowel |
| passed | dowel.build being a directory is refused |
| passed | dowel.build being a directory is refused with a source location |
| passed | dowel.build being a symlink loop does not abort dowel |
| passed | dowel.build being a symlink loop is refused |
| passed | dowel.build being a symlink loop is refused with a source location |
| passed | three independent errors are reported in one run |
ok projects/08-lsp — 110 checks (110 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | initialize is answered |
| passed | the server advertises hover |
| passed | the server advertises document sync |
| passed | didOpen publishes diagnostics even when there are none |
| passed | a valid manifest publishes an empty list |
| passed | didChange republishes for the new text |
| passed | didSave does not upset the server |
| passed | didClose clears the diagnostics of that document |
| passed | reopening a closed document publishes again |
| passed | shutdown and exit end the process cleanly |
| passed | the server survives a body that is not JSON |
| passed | diagnostics still arrive after a body that is not JSON |
| passed | the server survives a JSON body that is not a request |
| passed | diagnostics still arrive after a JSON body that is not a request |
| passed | the server survives a body shorter than Content-Length says |
| passed | the server survives a body with no Content-Length |
| passed | the server survives a Content-Length that is not a number |
| passed | an unknown method is answered with method-not-found |
| passed | the server survives an unknown method |
| passed | a broken manifest yields at least one diagnostic |
| passed | the diagnostic carries the stable code |
| passed | the diagnostic names dowel as its source |
| passed | a parse error is reported as an error |
| passed | the diagnostic carries a range |
| passed | diagnostic lines are zero based |
| passed | the column of a diagnostic is in UTF-16 units after ASCII |
| passed | the column of a diagnostic is in UTF-16 units after a two byte character |
| passed | the column of a diagnostic is in UTF-16 units after a three byte character |
| passed | the column of a diagnostic is in UTF-16 units after an astral plane character |
| passed | a hover position is read in UTF-16 units after ASCII |
| passed | a hover position is read in UTF-16 units after a two byte character |
| passed | a hover position is read in UTF-16 units after a three byte character |
| passed | a hover position is read in UTF-16 units after an astral plane character |
| passed | dowel check still reports unterminated-string |
| passed | the language server reports unterminated-string as dowel check does |
| passed | dowel check still reports expected-token |
| passed | the language server reports expected-token as dowel check does |
| passed | dowel check still reports unknown-char |
| passed | the language server reports unknown-char as dowel check does |
| passed | dowel check still reports expected-value |
| passed | the language server reports expected-value as dowel check does |
| passed | dowel check still reports missing-newline |
| passed | the language server reports missing-newline as dowel check does |
| passed | dowel check still reports unterminated-comment |
| passed | the language server reports unterminated-comment as dowel check does |
| passed | dowel check still reports duplicate-table |
| passed | the language server reports duplicate-table as dowel check does |
| passed | dowel check still reports unknown-function |
| passed | the language server reports unknown-function as dowel check does |
| passed | dowel check still reports unknown-cfg-key |
| passed | the language server reports unknown-cfg-key as dowel check does |
| passed | dowel check still reports non-exhaustive-match |
| passed | the language server reports non-exhaustive-match as dowel check does |
| passed | dowel check still reports unknown-property |
| passed | the language server reports unknown-property as dowel check does |
| passed | dowel check still reports unknown-kind |
| passed | the language server reports unknown-kind as dowel check does |
| passed | dowel check still reports type-mismatch |
| passed | the language server reports type-mismatch as dowel check does |
| passed | dowel check still reports toplevel-entry |
| passed | the language server reports toplevel-entry as dowel check does |
| passed | dowel check still reports missing-field |
| passed | the language server reports missing-field as dowel check does |
| passed | dowel check still reports expression-in-strict-toml in dowel.toml |
| passed | the language server reports expression-in-strict-toml in dowel.toml |
| passed | dowel check still reports expected-token in dowel.toml |
| passed | the language server reports expected-token in dowel.toml |
| passed | dowel check still reports unterminated-string in dowel.toml |
| passed | the language server reports unterminated-string in dowel.toml |
| passed | dowel check still reports duplicate-key in dowel.toml |
| passed | the language server reports duplicate-key in dowel.toml |
| passed | dowel check still reports missing-table in dowel.toml |
| passed | the language server reports missing-table in dowel.toml |
| passed | dowel check still reports empty-glob |
| passed | the language server scans the file system for empty-glob |
| passed | dowel check still reports no-sources |
| passed | the language server scans the file system for no-sources |
| passed | dowel check still reports invalid-source |
| passed | the language server scans the file system for invalid-source |
| passed | dowel check still reports unresolved-path |
| passed | the language server scans the file system for unresolved-path |
| passed | dowel check still reports missing-toolchain |
| passed | the language server looks for the declared compiler too |
| passed | dowel check refuses an unresolvable system package |
| passed | the language server does not run pkg-config to resolve it |
| passed | opening a manifest never writes dowel.lock |
| passed | hover on a property gives its type and merge rule |
| passed | hover on includes gives union as its merge rule |
| passed | hover on a builtin gives its signature |
| passed | hover on a configuration key gives its domain |
| passed | hover on a table kind explains the kind |
| passed | hover on a target name names the target |
| passed | hover on a block explains the block |
| passed | hover answers for sources while a later line has a parse error |
| passed | hover answers for glob while a later line has a parse error |
| passed | hover answers for includes while a later line has a parse error |
| passed | hover on a blank line answers with no contents |
| passed | hover past the end of the file answers with no contents |
| passed | hover past the end of a line answers with no contents |
| passed | the server survives hover positions that are out of range |
| passed | hover on an unknown property answers with no contents |
| passed | the server survives a didChange nested 64 deep |
| passed | the server answers a didChange nested 64 deep |
| passed | the server survives a didChange nested 1000 deep |
| passed | the server answers a didChange nested 1000 deep |
| passed | the server survives a didChange nested 100000 deep |
| passed | the server answers a didChange nested 100000 deep |
| passed | a UTF-8 BOM in the buffer is not reported as an error |
| passed | CRLF in the buffer is not reported as an error |
| passed | the server survives non-ASCII paths in the buffer |
ok projects/09-acquisition — 121 checks (120 passed, 0 failed, 1 known, 0 fixed)
| state | check |
|---|---|
| passed | installing a revision from the upstream succeeds |
| passed | the resolved commit is written to stdout |
| passed | installing an already installed revision succeeds and says so |
| passed | an installed revision appears in the list |
| passed | the installed revision is laid out under versions/<sha>/bin |
| passed | run starts the requested revision without selecting it |
| passed | the shim can be created |
| passed | the shim is a link named dowel |
| passed | with no pin and no default, nothing is selected |
| passed | the shim refuses to run when nothing is selected |
| passed | setting a default succeeds |
| passed | the default is used where no pin file applies |
| passed | a pin file is used in the directory that holds it |
| passed | a pin file is found by walking up from a subdirectory |
| passed | the nearest pin file wins over one further up |
| passed | selection works with the upstream unreachable |
| passed | the shim runs with the upstream unreachable |
| passed | pinning an installed revision needs no network |
| passed | pin writes the resolved commit to the pin file |
| passed | pin records which specifier it resolved from |
| passed | a pin file holding `nightly` is refused |
| passed | a pin file holding `stable` is refused |
| passed | a pin file holding `main` is refused |
| passed | a pin file holding `branch:side` is refused |
| passed | a pin file holding `19a4a40` is refused |
| passed | refusing a hand written channel name points at dowelup pin |
| passed | a pinned revision that is not installed is refused |
| passed | refusing an uninstalled revision points at dowelup install |
| passed | a pin file without a trailing newline is read |
| passed | a pin file with CRLF is read |
| passed | surrounding spaces in a pin file are ignored |
| passed | an uppercase commit hash in a pin file is read |
| passed | a pin file with no commit hash is refused |
| known | a pin file with a UTF-8 BOM is read [F-011] |
| passed | a branch that exists resolves |
| passed | a tag that exists resolves |
| passed | a release number resolves to its tag |
| passed | stable resolves to the newest tag |
| passed | a dated nightly resolves |
| passed | a branch that does not exist is refused |
| passed | a tag that does not exist is refused |
| passed | a date before the first commit is refused |
| passed | a malformed date is refused |
| passed | a commit hash prefix that is too short is refused |
| passed | a branch specifier with no name is refused |
| passed | an unresolvable commit is refused |
| passed | a malformed specifier and an unresolvable one exit differently |
| passed | a full commit hash selects an installed revision |
| passed | a commit hash prefix selects an installed revision |
| passed | the specifier it was installed from selects it |
| passed | installing the same commit under another specifier succeeds |
| passed | a specifier that installed successfully can select |
| passed | the first specifier still selects after a second one is added |
| passed | the list shows every specifier the revision was installed from |
| passed | an unknown specifier is refused by the shim |
| passed | refusing an unknown specifier points at dowelup list |
| passed | a leading specifier overrides the pin file |
| passed | installing a revision that does not build fails |
| passed | a failed install leaves nothing under versions/ |
| passed | a failed install does not appear in the list |
| passed | a failed install keeps its checkout for inspection |
| passed | a revision whose install failed is not selectable |
| passed | uninstalling by the specifier it was installed from succeeds |
| passed | an uninstalled revision leaves the list |
| passed | uninstalling removes the directory under versions/ |
| passed | uninstalling the same revision twice is refused |
| passed | selecting an uninstalled revision is refused |
| passed | installing a release succeeds |
| passed | installing a release needs no Rust toolchain |
| passed | install says the binary came from a release asset |
| passed | install says the asset was verified by its checksum |
| passed | install names the asset it fetched |
| passed | a binary taken from a release asset runs |
| passed | a binary taken from a release asset is laid out under versions/<sha>/bin |
| passed | `stable` takes the release asset too |
| passed | `tag:v0.9.0` takes the release asset too |
| passed | a specifier that names no release does not look for an asset |
| passed | install says why it is building instead of fetching |
| passed | a specifier that names no release goes to the source build |
| passed | --from-source does not fetch the asset |
| passed | --from-source builds a release from source |
| passed | an asset that does not match its checksum is refused |
| passed | the checksum mismatch shows both the expected and the actual digest |
| passed | a refused asset falls back to the source build |
| passed | an asset with no checksum beside it is refused |
| passed | an asset with no checksum falls back to the source build |
| passed | a checksum file in sha256sum's own format is accepted |
| passed | an uppercase checksum is accepted |
| passed | an asset that holds no dowel binary is refused |
| passed | an asset that holds no dowel binary falls back to the source build |
| passed | a release with no asset falls back to the source build |
| passed | the fallback really reaches cargo |
| passed | a failed fetch says why it failed |
| passed | a failed fetch says what each tool it tried reported |
| passed | the reason the asset path was abandoned survives into the failure |
| passed | a checksum mismatch also survives into the failure |
| passed | the surviving reason is the mismatch itself, not a generic one |
| passed | the record of a version taken from an asset says so |
| passed | the record keeps the digest that was verified |
| passed | the listing marks a version that arrived as a published binary |
| passed | which says which way the binary that would run here arrived |
| passed | which states the digest for a version taken from an asset |
| passed | the record of a version built from source says so |
| passed | a version built from source carries no asset digest |
| passed | the listing marks a version that was built from source |
| passed | resolving an installed version again records one arrival, not two |
| passed | resolving an installed version again keeps the way it first arrived |
| passed | resolving an installed version again still records the new specifier |
| passed | a second release can be created on the local mirror |
| passed | two named releases can be installed side by side |
| passed | and both arrived as published binaries |
| passed | asking for one release gives the payload published under it |
| passed | and asking for the other gives the payload published under that |
| passed | what was installed is byte for byte what the asset held |
| passed | and the digest it recorded is the one published beside the asset |
| passed | the dowel that was fetched can build a package |
| passed | and what it built runs |
| passed | a pin file selects the payload that came with the version it names |
| passed | and changing the pin changes which payload runs |
| passed | a payload that is not dowel at all installs, nothing checking what it is |
| passed | and --from-source is the way to demand a binary whose origin is shown |
ok projects/10-toolchain — 53 checks (53 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | gcc: check passes |
| passed | gcc: build passes |
| passed | gcc: the declared toolchain is what gets invoked |
| passed | gcc: the artifact was translated by the declared compiler |
| passed | gcc: the artifact agrees with the declaration, checked in C |
| passed | clang: check passes |
| passed | clang: build passes |
| passed | clang: the declared toolchain is what gets invoked |
| passed | clang: the artifact was translated by the declared compiler |
| passed | clang: the artifact agrees with the declaration, checked in C |
| passed | match on tc.c picks the clang arm |
| passed | match on tc.c picks the gcc arm |
| passed | the clang arm actually compiles under clang |
| passed | the gcc arm actually compiles under gcc |
| passed | switching the toolchain rebuilds |
| passed | the rebuilt artifact is the one the new toolchain produced |
| passed | building again with the same toolchain runs nothing |
| passed | switching back rebuilds as well |
| passed | switching back gives the earlier compiler's artifact again |
| passed | gcc: a first build runs every action |
| passed | gcc: a second build runs nothing |
| passed | gcc: editing a header rebuilds through the depfile |
| passed | gcc: and settles again |
| passed | clang: a first build runs every action |
| passed | clang: a second build runs nothing |
| passed | clang: editing a header rebuilds through the depfile |
| passed | clang: and settles again |
| passed | a toolchain that does not exist is refused |
| passed | the refusal carries the missing-toolchain code |
| passed | the refusal points at the declaration |
| passed | the missing toolchain never reaches the shell |
| passed | a toolchain declared with a url and a sha256 builds |
| passed | and the program it produced runs |
| passed | the compiler is resolved inside what was unpacked |
| passed | and it is the one the declaration named |
| passed | what was unpacked lives in the user's cache, one directory per archive |
| passed | and not inside the tree |
| passed | a later build never reaches for the archive again |
| passed | sysroot() expands to a path under the fetched toolchain |
| passed | writing sysroot() with none declared is refused |
| passed | and says where to declare it |
| passed | a url without a sha256 is refused |
| passed | and says why a url alone is not a pin |
| passed | an archive whose digest does not match is refused |
| passed | and shows what was expected and what arrived |
| passed | an archive that cannot be fetched is refused |
| passed | a toolchain that is not fetched is refused under --offline |
| passed | fetch acquires the toolchain |
| passed | and it really is unpacked into the cache |
| passed | after which the build runs offline |
| passed | fetch counts the toolchain it acquired |
| passed | and lists it among what is now present |
| passed | counting them apart, the two being different things to go and get |
ok projects/11-cross — 17 checks (17 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the host build passes |
| passed | the host build produces a host artifact |
| passed | the host artifact names its own architecture |
| passed | the host tests pass |
| passed | the cross build passes |
| passed | the cross build produces an artifact for the target |
| passed | the cross tests run under the emulator and pass |
| passed | the host and cross build directories both survive |
| passed | a second cross build runs nothing |
| passed | the host build is not confused by the cross build |
| passed | and the cross build is still up to date afterwards |
| passed | building for a triple with no toolchain declared is refused |
| passed | the refusal carries the missing-toolchain code |
| passed | the mismatch is caught before anything is built |
| passed | the host build still needs no declaration |
| passed | declaring the host compiler for another triple is allowed |
| passed | and it produces a host artifact, which readelf shows plainly |
ok projects/12-store — 43 checks (43 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the first run in a fresh tree stores and restores nothing |
| passed | the next process restores what the first one stored |
| passed | and stores nothing new when nothing changed |
| passed | a restored run still passes check |
| passed | a restored run still builds |
| passed | an untouched file is judged unchanged by its stat alone |
| passed | a touched file falls back to its content fingerprint |
| passed | a touched but unchanged file is still restored |
| passed | an edited file is judged changed |
| passed | an edited file is evaluated again and stored again |
| passed | a file whose evaluation produced diagnostics is not stored |
| passed | the diagnostic is reported on the first run |
| passed | and on the next process too, not only the first |
| passed | fixing the manifest clears the diagnostic in the next process |
| passed | a truncated value log does not change the answer |
| passed | an empty value log does not change the answer |
| passed | an index cut at a partial record does not change the answer |
| passed | an index full of noise does not change the answer |
| passed | a value log full of noise does not change the answer |
| passed | a missing index does not change the answer |
| passed | a missing value log does not change the answer |
| passed | a store written by an unknown format version does not change the answer |
| passed | the store recovers by itself after being corrupted |
| passed | cache info reports what the store holds |
| passed | cache info names the format version |
| passed | cache gc runs |
| passed | cache gc removes stores left by older formats |
| passed | cache gc keeps the store of the current format |
| passed | check still passes after gc |
| passed | overwriting a key leaves bytes behind, and cache info reports them as dead |
| passed | a run that ends over budget says so |
| passed | naming both how to collect it once and how to make it automatic |
| passed | and DOWEL_CACHE=off stops saying it |
| passed | while DOWEL_CACHE=gc compacts in place, which is what the note offers |
| passed | and the tree still builds after it |
| passed | cache info counts the build directories, one per configuration |
| passed | with how long ago each was written, which is what selects one for removal |
| passed | gc without a number leaves them all, since nobody said which are unused |
| passed | gc with a number removes a configuration nobody has built in that long |
| passed | leaving the one that is still in use |
| passed | and what was removed builds again |
| passed | cache info works even when the manifest is broken |
| passed | and so does gc |
ok projects/13-parallel — 18 checks (18 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | by default the tests do not overlap |
| passed | all of them pass when run sequentially |
| passed | --test-jobs=1 is the same as the default |
| passed | --test-jobs=4 really runs them at the same time |
| passed | all of them pass when run in parallel |
| passed | --test-jobs=2 overlaps as well |
| passed | every test still runs when only two go at a time |
| passed | the report keeps the requested order under parallelism |
| passed | a failing test fails the run when sequential |
| passed | the sequential summary counts it once |
| passed | a failing test fails the run when parallel |
| passed | the parallel summary counts it the same |
| passed | the exit status of the failing test survives parallelism |
| passed | --failed reruns only the failure after a parallel run |
| passed | --failed leaves the passing tests alone after a parallel run |
| passed | the repaired test passes again in parallel |
| passed | --test-jobs with a negative count is refused |
| passed | --test-jobs with a non-number is refused |
ok projects/14-scale — 17 checks (17 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | check passes on a package with 120 sources and 8 targets |
| passed | the first build runs one action per source, archive and link |
| passed | a second build runs nothing and accounts for every action |
| passed | editing one source of 120 rebuilds only it, the archive and the dependents |
| passed | editing one dependent rebuilds only that dependent |
| passed | editing the public header rebuilds everything that includes it |
| passed | adding one source compiles only the new one |
| passed | removing one source recompiles nothing and relinks the dependents |
| passed | the tests of the wide package still pass |
| passed | check passes through a 6 level dependency chain |
| passed | the first build of the chain runs every action |
| passed | a second build of the chain runs nothing |
| passed | editing the nearest level does not rebuild the whole chain |
| passed | editing the deepest header rebuilds only what includes it |
| passed | the chain still builds after the edits |
| passed | check on a large package stays far below the budget |
| passed | the plan phase is reported for a large package |
ok projects/15-cpp — 70 checks (70 passed, 0 failed, 0 known, 0 fixed)
README · capp · chain/deep · chain/mid · chain/topc · cpplib · cross/xapp · cross/xlib · exts · mixed · reverse/clib · reverse/cxxapp
| state | check |
|---|---|
| passed | a package of mixed extensions passes check |
| passed | a .cc source is compiled by the C++ driver |
| passed | a .cp source is compiled by the C++ driver |
| passed | a .cpp source is compiled by the C++ driver |
| passed | a .cxx source is compiled by the C++ driver |
| passed | a .c++ source is compiled by the C++ driver |
| passed | a .CPP source is compiled by the C++ driver |
| passed | a .C source is compiled by the C++ driver |
| passed | a .c source is still compiled by the C driver |
| passed | a C++ library passes check |
| passed | a C++ library builds |
| passed | the C++ source of the library uses the C++ driver |
| passed | a C binary that depends on a C++ library passes check |
| passed | its own source is compiled by the C driver |
| passed | but the link uses the C++ driver because a dependency is C++ |
| passed | the binary links and runs |
| passed | a C main gets the whole C++ runtime, not just the symbols |
| passed | running it exercises the standard library, exceptions and constructors |
| passed | a C test can call into the C++ library and pass |
| passed | the link never fails the way F-008 did |
| passed | a target holding both C and C++ sources passes check |
| passed | the C source of a mixed target uses the C driver |
| passed | the C++ source of a mixed target uses the C++ driver |
| passed | a mixed target links with the C++ driver |
| passed | the mixed binary agrees about which unit was compiled as what |
| passed | the mixed binary runs and its C and C++ halves both behave |
| passed | cxx defaults to c++ when nothing is declared |
| passed | a declared cxx is what gets invoked |
| passed | the library builds with the declared cxx |
| passed | match on tc.cxx follows the declaration |
| passed | and follows the default when nothing is declared |
| passed | a C++ package with a missing cxx is refused |
| passed | the refusal carries the missing-toolchain code |
| passed | the refusal points at the declaration |
| passed | the missing C++ compiler never reaches the shell |
| passed | a package with no C++ sources ignores a broken cxx declaration |
| passed | and still builds |
| passed | a chain of C packages over a C++ leaf passes check |
| passed | the C++ leaf of the chain uses the C++ driver |
| passed | the C layer between them uses the C driver |
| passed | and so does the root |
| passed | the root links with the C++ driver although its dependency is C |
| passed | the chain builds and its test passes |
| passed | the root binary runs through two C layers into C++ |
| passed | a C++ binary that depends on a C library passes check |
| passed | the C dependency uses the C driver |
| passed | the C++ binary uses the C++ driver |
| passed | the link uses the C++ driver in this direction too |
| passed | the C++ binary builds and runs |
| passed | a test target written in C++ builds and passes |
| passed | the mixed target builds from scratch |
| passed | and settles |
| passed | a depfile is written for the C++ translation unit too |
| passed | editing a header that only C++ reads rebuilds through the C++ depfile |
| passed | and the artifact reflects the new value |
| passed | editing a header that only C reads rebuilds through the C depfile |
| passed | and the artifact reflects that too |
| passed | g++ is used when it is declared |
| passed | the library builds with g++ |
| passed | clang++ is used when it is declared |
| passed | the library builds with clang++ |
| passed | the C and C++ compilers can come from different families |
| passed | the library builds with a mixed pair |
| passed | a cross C++ package passes check |
| passed | the cross C++ compiler is used for the C++ source |
| passed | the cross C compiler is used for the C source |
| passed | the cross link uses the cross C++ driver |
| passed | the cross C++ build produces an artifact |
| passed | the cross C++ artifact is built for the target architecture |
| passed | the cross C++ test runs under the emulator and passes |
ok projects/16-migrate — 87 checks (87 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | cmake writes a compile database for the reference build |
| passed | import drafts a manifest pair from the CMake File API |
| passed | import writes a package manifest |
| passed | import writes a build manifest |
| passed | the package manifest is marked as an unverified draft |
| passed | the build manifest is marked as an unverified draft |
| passed | import points at the verify step that checks its own output |
| passed | the package takes its name from the CMake project |
| passed | an executable becomes a bin target |
| passed | a static library becomes a lib target |
| passed | sources are listed one by one |
| passed | globbing is not used for the imported sources |
| passed | an in-project link becomes a target() dependency |
| passed | includes and defines land in a private block |
| passed | nothing is drafted as public |
| passed | the drafted manifests pass check |
| passed | the drafted manifests build |
| passed | the binary built from the draft runs and agrees with the CMake build |
| passed | import refuses to overwrite manifests that are already there |
| passed | the refusal leaves the existing manifest untouched |
| passed | the refusal says the manifests are already there |
| passed | a build directory with no File API reply is refused |
| passed | the refusal says how to produce the reply |
| passed | every buildable target kind is imported |
| passed | an object library becomes a lib target |
| passed | a shared library becomes a lib target too |
| passed | the draft says out loud that a shared library became a static one |
| passed | an interface library does not become a target of its own |
| passed | what an interface library handed to its users survives |
| passed | a system library becomes a link flag |
| passed | verify compares plans, so it needs no build of its own |
| passed | the compiler name, -c, -o and the -MD family are not differences |
| passed | -DA, -D A=1 and -DA=1 are the same define |
| passed | a relative include is resolved against the entry's directory |
| passed | the order of the arguments is not a difference |
| passed | a genuine difference is still reported |
| passed | the difference names both what the reference had and what dowel has |
| passed | a differing entry makes the comparison fail |
| passed | a file only dowel builds is counted apart, and does not fail |
| passed | a file the reference builds and dowel does not is counted as not ported |
| passed | the text form reports the same four buckets as the json form |
| passed | a reference that is not there is refused |
| passed | a reference that is not JSON is refused |
| passed | an empty reference is refused |
| passed | a release build directory is imported the same way |
| passed | the draft carries no optimization flag from the CMake build type |
| passed | the CMake build type does not become a define in the draft |
| passed | the draft carries no NDEBUG from a release CMake build type |
| passed | the drafted debug build of a debug import is unoptimized |
| passed | the drafted release build is actually optimized |
| passed | the drafted debug build keeps assertions |
| passed | the drafted release build of a release import is optimized |
| passed | the workflow that import prints verifies clean |
| passed | verify ignores the build type on both sides, so any pairing is clean |
| passed | meson writes its introspection without being asked, unlike CMake's File API |
| passed | import reads a Meson build directory |
| passed | and the draft says it is unverified, the same as one imported from CMake |
| passed | naming Meson as where it came from |
| passed | the sources of each target are listed explicitly |
| passed | with the defines sorted out of the parameters array |
| passed | and the include directories too |
| passed | while the configuration-level flags are not, since dowel's own --config supplies them |
| passed | and deps is left empty, because Meson does not say which target links which |
| passed | the compile flags carry nothing that belongs to the link or the archiver |
| passed | the linker's own arguments go to link_flags instead |
| passed | and what was dropped is noted rather than removed silently |
| passed | naming both the archive it saw and the archiver's argument string |
| passed | and says what to write instead, which is the edge Meson never reported |
| passed | so what still stops the draft is the missing edge, not the arguments |
| passed | while verify still reports what differs, which is what makes the draft checkable |
| passed | the same tree imports from CMake as well |
| passed | and that draft builds without editing |
| passed | import marks every target it drafted |
| passed | one mark per target, the unit of migration being the target |
| passed | every plan reports what is still unverified |
| passed | as a warning, so the draft still builds and runs |
| passed | and the draft does build with the mark in place |
| passed | saying that everything came in private |
| passed | and that dropped link inputs are not dependencies yet |
| passed | and pointing at the step that checks it |
| passed | the mark is machine readable, so an editor can underline it |
| passed | verify counts what is still marked, beside the source-level verdict |
| passed | and reporting the compile lines as equivalent is not a contradiction with that |
| passed | a clean verify does not clear the mark, that claim being the user's to make |
| passed | removing a line by hand is what moves the count |
| passed | a mark written by hand is reported the same way |
| passed | and counted the same way, dowel not distinguishing who wrote it |
ok projects/17-deps — 83 checks (83 passed, 0 failed, 0 known, 0 fixed)
README · app · archived · chain/mid · chain/top · gated · packed/greet-1.0
| state | check |
|---|---|
| passed | a version dependency resolves through pkg-config |
| passed | the resolved module enters the graph as a package |
| passed | a package with a resolved system dependency builds |
| passed | the module's cflags and libs both reach the build |
| passed | the module's --cflags become compile flags |
| passed | the module's --libs become link flags |
| passed | a version equal to what the system has is satisfied |
| passed | a version below what the system has is satisfied |
| passed | a version above what the system has is refused |
| passed | the refusal carries the unsatisfied-dependency code |
| passed | the refusal names the constraint that was not met |
| passed | the refusal says the constraint is a minimum |
| passed | the refusal points at the declaration in dowel.toml |
| passed | the refusal spans the declaration, not the whole file |
| passed | a module the system does not have is refused |
| passed | an unknown module is refused with the same code as a version mismatch |
| passed | the refusal names path and git as the way out |
| passed | putting the module name back makes it resolve again |
| passed | a version dependency is refused when pkg-config cannot be run |
| passed | the refusal says that pkg-config itself could not be run |
| passed | the resolution is recorded in dowel.lock |
| passed | the lock records the version that was resolved, not the one declared |
| passed | the lock names where the resolution came from |
| passed | the lock says it detects a change rather than restoring one |
| passed | a second check with a matching lock passes |
| passed | a matching lock is left byte for byte alone |
| passed | a matching lock says nothing |
| passed | a lock that disagrees with the system warns |
| passed | the drift is a warning, not an error |
| passed | the warning names both the resolved version and the recorded one |
| passed | the warning says how to accept the new resolution |
| passed | a drifted lock does not fail the build |
| passed | a drifted lock is never rewritten on its own |
| passed | removing the entry lets the resolution be recorded again |
| passed | the freshly recorded entry holds what the system has |
| passed | and the drift warning is gone |
| passed | an unrelated entry does not disturb the check |
| passed | an unrelated entry in the lock is kept |
| passed | an inactive optional version dependency is not resolved at all |
| passed | an inactive optional version dependency is not recorded either |
| passed | enabling the feature resolves the optional module |
| passed | and then it is recorded |
| passed | a module with no link flags builds all the same |
| passed | the archive of a private system dependency reaches the final link |
| passed | keeping a system dependency private does not leak its includes |
| passed | the link flags of a private system dependency reach the final link |
| passed | a library that keeps a system dependency private still links its dependent |
| passed | and its includes are still not leaked to the dependent |
| passed | declaring the same dependency public does link |
| passed | a public system dependency puts its link flags on the final link |
| passed | but a public system dependency also hands its defines to the dependent |
| passed | a package declared as a pinned archive builds |
| passed | and what it built runs |
| passed | unpacked into a directory named for the digest of what was fetched |
| passed | with the single top-level directory stripped, as the usual wrapper is |
| passed | the fetched package's public defines reach the dependent |
| passed | an archive without a digest is refused |
| passed | saying why a URL alone is not a pin |
| passed | a digest that is not 64 hex digits is refused too |
| passed | naming the shape it wanted |
| passed | a digest that does not match reports both what was expected and what arrived |
| passed | and nothing is unpacked, because the check happens before the archive is opened |
| passed | an archive that cannot be fetched is refused |
| passed | the archive is fetched once |
| passed | and a later build never reaches for it again |
| passed | which is a build that runs nothing, having everything already |
| passed | removing what was unpacked makes the next build fetch it again |
| passed | a dependency that is not fetched is refused under --offline |
| passed | and says where it would have come from |
| passed | and how to get it |
| passed | the environment variable does the same as the flag |
| passed | fetch acquires what the build needs |
| passed | and lists what is now present |
| passed | and says that the build can now run offline |
| passed | fetch compiles nothing |
| passed | the build then runs with --offline |
| passed | and so does check |
| passed | removing what was unpacked brings needs-fetch back |
| passed | and fetching once makes it work again |
| passed | --offline says nothing about resolving a system dependency |
| passed | a fetch that was tried and failed has its own code |
| passed | while the same tree under --offline reports nothing was tried |
| passed | fetch fails when it cannot acquire what it was asked for |
ok projects/18-tools — 33 checks (33 passed, 0 failed, 0 known, 0 fixed)
README · cross · host · typo · vocab
| state | check |
|---|---|
| passed | the archiver defaults to ar when nothing is declared |
| passed | the C compiler defaults to cc, as it always has |
| passed | a declared archiver is the one that runs |
| passed | declaring the archiver leaves the compiler alone |
| passed | the package builds with the declared archiver |
| passed | match on tc.ar follows the declaration |
| passed | and falls to the default arm when nothing is declared |
| passed | a tc.* key that is not a declared tool is refused |
| passed | the refusal names the key that was written |
| passed | an archiver that is not on PATH is refused |
| passed | the refusal carries the missing-toolchain code |
| passed | the refusal says it is the archiver, not the compiler |
| passed | the missing archiver never reaches the shell |
| passed | a target that produces no archive ignores a broken archiver |
| passed | a rebuild with the same archiver runs nothing |
| passed | changing the declared archiver rebuilds |
| passed | the archive is what gets rebuilt |
| passed | the objects are not recompiled for a different archiver |
| passed | swapping what the name resolves to rebuilds, the identity being what is recorded |
| passed | and settles again once the new identity is the recorded one |
| passed | a cross build uses the archiver declared for that triple |
| passed | and the compiler declared for the same triple |
| passed | the host build still uses the host archiver |
| passed | the cross build passes check |
| passed | the cross build produces an archive |
| passed | the objects inside the cross archive are for the target architecture |
| passed | the cross binary links against that archive and runs under the emulator |
| passed | a misspelled toolchain key is refused |
| passed | the refusal suggests the tool that was meant |
| passed | the misspelled declaration is caught before anything is built |
| passed | spelling the key correctly does select the cross archiver |
| passed | a transform tool can be declared alongside the archiver |
| passed | an inspection tool can be declared alongside the archiver |
ok projects/19-artifacts — 35 checks (35 passed, 0 failed, 0 known, 0 fixed)
README · cross · firmware · library
| state | check |
|---|---|
| passed | a package with an artifacts block passes check |
| passed | and builds |
| passed | an artifacts entry produces its derived file |
| passed | a second entry produces a second file |
| passed | the artifact it derives from is still there |
| passed | the raw image is not an ELF, so the transform really ran |
| passed | the raw image carries what the source put in the artifact |
| passed | the hex image is in the format the second entry asked for |
| passed | the command is the tool, then the args, then the input and the output |
| passed | a declared objcopy that is not on PATH is refused |
| passed | the refusal carries the missing-toolchain code |
| passed | the refusal names the object copier |
| passed | a package with no artifacts block ignores a broken objcopy |
| passed | a tool outside the toolchain table is refused |
| passed | the refusal lists the tools that can be named |
| passed | the refusal says the concrete command comes from the toolchain |
| passed | an entry with no tool is refused |
| passed | an entry that is not a table is refused |
| passed | restoring the block makes it pass again |
| passed | a second build re-runs no transform |
| passed | editing the source re-makes the derived file |
| passed | changing the args re-makes the derived file |
| passed | and does not recompile anything |
| passed | a cross build transforms with the objcopy declared for that triple |
| passed | the artifacts block never names the cross tool itself |
| passed | the cross build produces its image |
| passed | the derived file of a cross build is produced too |
| passed | and the same manifest uses the host objcopy for a host build |
| passed | a library with an artifacts block builds on its own |
| passed | a standalone library produces its derived file |
| passed | adding a binary that uses it still builds |
| passed | the library archive is still produced as a dependency |
| passed | a library keeps producing its derived file when a binary depends on it |
| passed | naming the library explicitly builds it |
| passed | and then the derived file appears |
ok projects/20-cases — 62 checks (62 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | a package that registers cases passes check |
| passed | and all of its cases pass |
| passed | each case is reported under <package>:<target>/<case> |
| passed | a target with no cases block is one test named after the target |
| passed | cases add no translation unit; five of them share one binary |
| passed | the args of a case reach the binary |
| passed | the env of a case reaches the binary |
| passed | should_fail turns a nonzero exit into a pass |
| passed | and a case that was supposed to fail says so rather than reporting a bare status |
| passed | a case past its timeout is killed and reported as timed out |
| passed | a timeout wins over should_fail, so a hang is never an expected failure |
| passed | a case killed by a signal does not satisfy should_fail |
| passed | and the failure names the signal, not a bare status |
| passed | and the report distinguishes a crash from a nonzero exit |
| passed | a timeout of zero or less is refused |
| passed | a label selects the cases that carry it |
| passed | naming a label nobody carries does not pass with zero tests |
| passed | and it does say which label found nothing |
| passed | and points at the listing that shows the labels that do exist |
| passed | the label a case is reported under selects that case on the command line |
| passed | naming the target runs all of its cases |
| passed | --fail-fast stops at the first failure and says how many did not run |
| passed | --failed reruns the case that failed, not its whole target |
| passed | rerunning failures says so when the remembered case is gone |
| passed | cases of one target run at the same time under --test-jobs |
| passed | and the display stays in request order however many run at once |
| passed | an unknown key in a case is refused |
| passed | and the accepted keys are listed |
| passed | a value of the wrong type in a case is refused |
| passed | a type error inside a case points at the key that is wrong |
| passed | a case name that breaks the label grammar is refused |
| passed | and the diagnostic says why the grammar owns that character |
| passed | two cases with the same name are refused |
| passed | writing a case as a table header says how to write it as an entry |
| passed | a cases block on a bin target is refused |
| passed | with what to do instead |
| passed | a cases block with no case in it is not silently one bare run |
| passed | a value inside a case can branch on the configuration |
| passed | a case can be registered only for some configurations |
| passed | the case exists in the configuration its condition names |
| passed | and is absent from the one it does not |
| passed | the schema dump describes the properties a case accepts |
| passed | and the runner's, which was the other block missing from it |
| passed | and the case keys it lists are exactly the ones the type checker accepts |
| passed | the cases that would run can be listed without running them |
| passed | with the properties that change how a case is judged |
| passed | and the listing honours the selection that was asked for |
| passed | the machine-readable results go to stdout while the progress goes to stderr |
| passed | the machine-readable result names the target and the case separately |
| passed | and says whether the case was expected to fail |
| passed | a case runs in the root of the package that declares it |
| passed | a case can be given the directory it runs in |
| passed | the binary lists its own cases and each runs as its own test |
| passed | blank lines and comment lines in the listing are skipped |
| passed | a label declared on the harness reaches every discovered case |
| passed | cases and harness cannot both be declared |
| passed | a listing that fails is a failure of the target, not zero tests |
| passed | and a listing that hangs is killed by the harness timeout |
| passed | a discovered name that breaks the label grammar is not silently accepted |
| passed | naming the offending name and the grammar it would break |
| passed | and pointing at the harness, which is where such a name has to be fixed |
| passed | a discovered case reports under the same label grammar as a declared one |
ok projects/21-debug — 32 checks (32 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the package passes check |
| passed | the debugger is a toolchain tool with a default per argument style |
| passed | a library cannot be debugged, because there is nothing to start |
| passed | dowel builds the target and starts the declared debugger |
| passed | and hands it the artifact it just built |
| passed | a debugger that is not on PATH is refused when debugging |
| passed | while an ordinary build never asks for it |
| passed | a breakpoint set through dowel stops the program where the source says |
| passed | and the debugger can evaluate expressions in the stopped program |
| passed | a cross debug session attaches to the declared stub address |
| passed | and stops the foreign binary at the same source line |
| passed | the stub is killed when the debugger exits |
| passed | a cross target whose runner declares no stub is refused |
| passed | a half-declared stub is told which half is missing |
| passed | naming the missing half rather than reporting the pair as absent |
| passed | pointing at the half that is there, and naming the key that completes it |
| passed | --dap writes a launch configuration instead of starting anything |
| passed | naming the artifact the session would have opened |
| passed | with the package root as the working directory, the same as dowel test |
| passed | a cross launch carries the declared attach address |
| passed | and the debugger the triple declared, not the host's |
| passed | and the stub command that hosts the program behind it |
| passed | the failing case's arguments become the launch arguments |
| passed | and its environment |
| passed | and the directory the case declared it runs in |
| passed | when nothing failed there is nothing to debug, and that is a success |
| passed | two recorded failures refuse to guess which one to open |
| passed | and ask to name one, listing the candidates |
| passed | naming a case narrows the choice to it |
| passed | a case that has not failed can be opened under the debugger |
| passed | carrying that case's own arguments, not a bare run of the binary |
| passed | while a case that does not exist is refused rather than opened as the bare target |
ok projects/22-bench — 34 checks (34 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the package passes check |
| passed | bench is a target kind, and an implemented one |
| passed | dowel bench builds the targets and measures them |
| passed | reporting min and median over the requested number of runs |
| passed | each declared case is measured in its own right |
| passed | under the same label grammar a test case has |
| passed | and naming one measures only it |
| passed | the machine-readable form emits one bench-result per measurement |
| passed | with min never above median, and median never above max |
| passed | and the times given as whole microseconds, leaving the rendering to the reader |
| passed | the number of runs is the one asked for |
| passed | and ten when nothing is asked |
| passed | carrying the arguments the case was measured with |
| passed | the slow case really is slower, which is a measurement and not a verdict |
| passed | so a benchmark that takes longer still succeeds |
| passed | and dowel offers no threshold of its own, leaving that to whatever reads the JSON |
| passed | a run that could not be completed fails the whole invocation |
| passed | naming what happened to it |
| passed | and no numbers at all for it, because a partial series reads as a finished measurement |
| passed | the machine-readable form withholds them too |
| passed | while the cases that did complete are still reported |
| passed | a case that never returns is killed by its timeout and reported as unmeasurable |
| passed | with no numbers for it either |
| passed | dowel test runs the tests and not the benchmarks |
| passed | and dowel bench runs the benchmarks and not the tests |
| passed | while an ordinary build produces both, since a benchmark is still an executable |
| passed | a bench case may not declare should_fail |
| passed | and the refusal names it, because a measurement has no verdict to invert |
| passed | nor may a bench discover its cases through a harness |
| passed | and a library cannot be benchmarked, having nothing to start |
| passed | a benchmark case can be opened under the debugger, carrying its arguments |
| passed | a second build of the benchmark runs nothing |
| passed | editing the measured source recompiles it |
| passed | and leaves the test that shares the package alone |
ok projects/23-probe — 23 checks (23 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the package builds with the renamed compiler |
| passed | a fact database appears in the user's cache area |
| passed | and not inside the project, because a fact belongs to the tool |
| passed | recording what the compiler answered when asked what it calls itself |
| passed | the triple the compiler calls itself is accepted as the host |
| passed | and so is the one dowel was built with, since both name this machine |
| passed | while a genuinely foreign triple is still refused |
| passed | a second build in the same tree records nothing new |
| passed | a second package builds with the same compiler |
| passed | and asks the tool nothing again, because the answer is not a property of the tree |
| passed | the key carries the tool's path, size and mtime |
| passed | the tree still builds after the tool is replaced |
| passed | replacing it asks again under a new key, rather than trusting the old answer |
| passed | leaving the old record in place, unreachable rather than wrong |
| passed | cache info names the per-project store |
| passed | and the per-user fact database beside it |
| passed | giving the path it actually used, which is the one to delete by hand |
| passed | cache info works even when the manifest is broken |
| passed | the tree builds again after the fact database is deleted by hand |
| passed | and the next run asks again, writing what it learned back |
| passed | arriving at the same answer, because the tool has not changed |
| passed | gc runs without a manifest too |
| passed | and the tree still builds after it |
ok projects/24-install — 55 checks (55 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | installing a library succeeds |
| passed | installing a library writes lib/libshapes.so.2 |
| passed | installing a library writes lib/libshapes.so |
| passed | installing a library writes lib/librender.a |
| passed | installing a library writes include/shapes.h |
| passed | installing a library writes include/render.h |
| passed | installing a library writes lib/pkgconfig/shapes.pc |
| passed | installing a library writes lib/pkgconfig/render.pc |
| passed | the unversioned name of a versioned library is a symlink |
| passed | what is installed is the published directory, not the sources beside it |
| passed | what is installed is the same bytes that were built |
| passed | installing without a destination is refused |
| passed | refusing it names the option that is missing |
| passed | installing a package with a test target succeeds |
| passed | a bin target is installed |
| passed | a test target is not installed |
| passed | a shared library the executable needs is installed with it |
| passed | installing a binary does not bring its dependency's headers |
| passed | naming a target installs that one |
| passed | the named target is installed |
| passed | an installed executable records a search path relative to itself |
| passed | the build tree path stays alongside it |
| passed | the installed tree runs after it is moved and the build tree is gone |
| passed | the direct backend records the relative search path unmangled |
| passed | the ninja backend records the relative search path unmangled |
| passed | the make backend records the relative search path unmangled |
| passed | installing into a staging directory succeeds |
| passed | --destdir prepends a staging root to every destination |
| passed | the descriptor names the real prefix, not the staging directory |
| passed | a staged executable carries the same relative search path |
| passed | a staged tree unpacked somewhere else runs |
| passed | installing into an empty staging directory yields the file list |
| passed | the descriptor names the target |
| passed | the descriptor carries the package version |
| passed | the descriptor carries the declared description |
| passed | Cflags points at the installed include directory |
| passed | Cflags carries the defines the library publishes |
| passed | Libs names the library itself |
| passed | Libs carries the link flags the library publishes |
| passed | the descriptor validates as pkg-config input |
| passed | a bin target gets no pkg-config descriptor |
| passed | a consumer that knows nothing about dowel compiles against the installed library |
| passed | and the program it produced runs |
| passed | a consumer links against an installed library that sits on a sibling |
| passed | and the program it produced runs |
| passed | the descriptor of a library that sits on a sibling names what it requires |
| passed | and what it names was written by the same run, beside it |
| passed | so a define the sibling publishes reaches the consumer too |
| passed | installing still succeeds, the behaviour being what was declared |
| passed | and says the interface directory holds sources |
| passed | pointing at the declaration, which is where the fix goes |
| passed | and saying why it does not filter them out |
| passed | one declaration produces one diagnostic, not one per file |
| passed | the directory goes whole and unfiltered, as the note says |
| passed | a directory that holds only headers says nothing |
ok projects/25-asm — 53 checks (53 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | a target mixing C and assembly builds |
| passed | and the program it produced runs |
| passed | the progress line for assembly says AS |
| passed | and the one for C still says CC |
| passed | the action graph describes it as an assembly step |
| passed | a language-independent flag reaches assembly |
| passed | a C standard does not reach assembly |
| passed | a C-only flag does not reach assembly |
| passed | an assembly-only flag reaches assembly |
| passed | an assembly-only flag does not reach C |
| passed | C still gets its own standard and flags |
| passed | a preprocessed assembly source is assembly too |
| passed | dowel adds the flag that marks the stack non-executable |
| passed | the executable it produced does not ask for an executable stack |
| passed | what dowel adds comes before what the target declares, so the target can override it |
| passed | a preprocessed assembly source asks for a depfile |
| passed | a plain assembly source does not, because none would be written |
| passed | editing a header a preprocessed assembly source includes rebuilds it |
| passed | and the change reaches the program |
| passed | the direct backend leaves nothing to redo on the next build |
| passed | the ninja backend leaves nothing to redo on the next build |
| passed | the make backend leaves nothing to redo on the next build |
| passed | a spelling dowel cannot compile is refused |
| passed | and check does not pass a tree that holds one |
| passed | with the position where it was declared as a source |
| passed | naming the file, not an object inside the build directory |
| passed | and listing the languages it does compile |
| passed | and saying what the C driver would have done with it |
| passed | a source with no extension is refused too |
| passed | a preprocessed C source is accepted, being C the driver takes |
| passed | the direct backend fails when a tool writes nothing it was asked for |
| passed | and says that the command exited 0 without writing its output |
| passed | showing the tool's own words, which usually explain it |
| passed | the ninja backend fails there too, the net being after the build |
| passed | and the ninja failure names the artifact that never appeared |
| passed | the make backend fails there too, the net being after the build |
| passed | and the make failure names the artifact that never appeared |
| passed | a tool that does write its output still succeeds |
| passed | a package that declares its own assembler builds |
| passed | and the program it produced runs |
| passed | the declared assembler is what assembles, not the C driver |
| passed | and asm_flags reach it, being where what it needs is written |
| passed | while the C driver's own flags do not |
| passed | and neither does what the target declared for every language |
| passed | a path written in asm_flags arrives as a path, there being no concatenation |
| passed | no depfile is asked for, its spelling being that assembler's and not the tool slot's |
| passed | the link carries the claim about the stack instead |
| passed | and the executable that came out does not ask for an executable stack |
| passed | a .asm source with no assembler declared is refused |
| passed | naming the file that needs one |
| passed | and saying what that spelling is |
| passed | and how to declare one |
| passed | and points at the source, as its sibling diagnostic does |
ok projects/26-prebuilt — 28 checks (28 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | a target that names a prebuilt library builds |
| passed | and the program it produced runs |
| passed | a consumer of a prebuilt library compiles against its published headers |
| passed | building a prebuilt library runs no compile and no archive of its own |
| passed | while its consumer is compiled as usual |
| passed | why traces a value back to the prebuilt target |
| passed | and the link flags it publishes arrive with it |
| passed | a prebuilt library that is not there fails |
| passed | and says so with its own code |
| passed | with the position of the declaration |
| passed | naming the path it looked for |
| passed | and saying that dowel does not produce it |
| passed | replacing the prebuilt library relinks its consumer |
| passed | declaring both sources and prebuilt is refused |
| passed | and says a target is built here or was built elsewhere |
| passed | a bin that names a prebuilt library is refused |
| passed | and says what a prebuilt is for |
| passed | a prebuilt library requiring another libc than the build is refused |
| passed | with the code the label system already had |
| passed | naming what the surface requires |
| passed | and the triple the build actually is |
| passed | and says why nothing later would catch it |
| passed | one wrong declaration produces one diagnostic |
| passed | and adding another consumer does not add another copy of it |
| passed | a prebuilt library requiring the libc the build has passes |
| passed | a surface may say more than the other side without blocking it |
| passed | and the merged label is the union of what was said |
| passed | keeping what the other side said too |
ok projects/27-generate — 61 checks (55 passed, 0 failed, 6 known, 0 fixed)
| state | check |
|---|---|
| passed | a package whose sources are generated builds |
| passed | and the program it produced runs |
| passed | the generated source is compiled into the target that declares it |
| passed | the action graph names each generation as its own kind of step |
| passed | each generation gets a directory of its own, named for it |
| passed | and the program runs in it, which is why the outputs are plain names |
| passed | the inputs are appended after the arguments, as everywhere else |
| passed | and a file() in the arguments opens to an absolute path |
| passed | the output directory joins the include path without being declared |
| passed | and public = true propagates it to a dependent |
| passed | while a generation that does not say public stays with its own target |
| passed | a first build runs the generation |
| passed | and a second runs nothing |
| passed | editing what the generation reads runs it again |
| passed | and recompiles the source it produced |
| passed | the program that comes out is the new one |
| passed | the dependent is recompiled too, having seen the generated header |
| passed | every compile in the reach takes the generated outputs as inputs |
| passed | a clean build under ninja never lets a compile outrun the generation |
| passed | and what ninja built prints the same thing |
| passed | a clean build under make never lets a compile outrun the generation |
| passed | and what make built prints the same thing |
| passed | a clean build under direct never lets a compile outrun the generation |
| passed | and what direct built prints the same thing |
| passed | a generation with two outputs builds under ninja |
| passed | while make refuses it |
| passed | saying it takes one output per step |
| passed | and naming a backend that has no such limit |
| passed | a generator that is not on PATH fails |
| passed | with its own code |
| passed | at the declaration |
| passed | naming the program it looked for |
| passed | and saying it runs on the build machine |
| passed | so [toolchain] is not where it comes from |
| passed | an output naming a path outside its directory is refused |
| passed | naming the output that leaves |
| passed | and saying what the names are relative to |
| passed | a generation that writes nothing is refused |
| passed | and says why that is a declaration error |
| passed | ninja refuses a command it cannot spell |
| passed | saying what ninja cannot spell |
| passed | and naming the spelling that works everywhere, to ninja's reader |
| passed | and the backend that runs argv without a shell (ninja) |
| passed | make refuses a command it cannot spell |
| passed | saying what make cannot spell |
| passed | and naming the spelling that works everywhere, to make's reader |
| passed | and the backend that runs argv without a shell (make) |
| passed | and writes no build file at all, rather than a half-written one |
| passed | the same declaration builds under direct, which passes argv |
| passed | and the file it wrote holds the newline that was asked for |
| passed | two generations may share a name across targets |
| passed | each writing into a directory named for its own target |
| passed | and neither one overwrites the other |
| passed | direct fails a generation that does not write what it declared |
| passed | naming the generation, not the compiler's word two stages later |
| known | ninja fails it too, the declared output not being there [F-068] |
| known | make fails it too, the declared output not being there [F-068] |
| known | one rejected output produces one diagnostic [F-069] |
| known | a refusal a backend makes carries a code, like every other refusal [F-070] |
| known | editing the program a generation runs re-runs it [F-071] |
| known | why accounts for the include path a generation put on the command line [F-072] |
ok projects/28-progress — 19 checks (19 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | --jobs 1 runs the steps one at a time |
| passed | and what it built runs |
| passed | --jobs 4 really runs steps at the same time under direct |
| passed | and the default is the machine's parallelism, not one |
| passed | --jobs 4 runs steps at the same time under ninja too |
| passed | --jobs 4 runs steps at the same time under make too |
| passed | a clean concurrent build produces the same program every time |
| passed | and ninja builds the same program with steps running at once |
| passed | and make builds the same program with steps running at once |
| passed | and direct builds the same program with steps running at once |
| passed | progress does not go to stdout, which stays for what the command returns |
| passed | --log-level=off silences it, being the only knob for silence |
| passed | ninja prints one line per step at the default log level (10 of 10) |
| passed | make prints one line per step at the default log level (10 of 10) |
| passed | direct prints one line per step at the default log level (10 of 10) |
| passed | direct counts the steps it ran out of the steps in the graph |
| passed | and the numbers arrive in order, matching the lines |
| passed | an incremental build stops short of m, m being the size of the build |
| passed | the progress lines arrive while the build runs, not replayed at the end |
ok projects/29-tool-identity — 21 checks (21 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | a package whose compiler is a wrapper builds |
| passed | and what it built runs |
| passed | a stamp is written for the tool, named for it and for its declaration |
| passed | and holds the identity of the program as resolved, not of the name |
| passed | the graph carries the stamps a reader has to write before running |
| passed | and every action takes the stamp of its own program, link and archive too |
| passed | the build graph says version 2, a version-1 reader having no stamps to write |
| passed | direct: the program built by the first wrapper runs |
| passed | direct: replacing the compiler rebuilds what it produced |
| passed | ninja: the program built by the first wrapper runs |
| passed | ninja: replacing the compiler rebuilds what it produced |
| passed | make: the program built by the first wrapper runs |
| passed | make: replacing the compiler rebuilds what it produced |
| passed | an unchanged tool leaves its stamp alone, mtime being what rebuilds |
| passed | and a build with the same tool runs nothing |
| passed | two spellings of the same program get two stamps, the digest being of the spelling |
| passed | and their contents are equal, both resolving to the same program |
| passed | check passes without building |
| passed | and writes no stamp, planning only stat-ing what it decides from |
| passed | a compiler that is not there fails |
| passed | with its own code |
ok apps/blink — 59 checks (59 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the bare-metal package passes check |
| passed | and builds |
| passed | the artifact needs no shared library at run time |
| passed | and carries no symbol from the standard library or its start-up |
| passed | the artifact is for the target architecture |
| passed | and its float ABI agrees with the hf in the triple |
| passed | the entry point is the reset handler, not a libc start-up routine |
| passed | the vector table survives into the artifact although nothing calls it |
| passed | a package can say which targets it is for |
| passed | and leaving out --target is refused |
| passed | by the package itself, with a diagnostic of its own |
| passed | the message is about the package's targets, not about a flag |
| passed | and the host compiler is never reached |
| passed | without the declaration the host compiler is what complains |
| passed | a raw image is produced |
| passed | an Intel HEX is produced |
| passed | the raw image is no longer an ELF |
| passed | the hex image is in the format the entry asked for |
| passed | the image is made by the objcopy declared for the triple |
| passed | a linker script inside the package can be named from the manifest |
| passed | and the image lands at the start of flash, where it can be programmed |
| passed | and the firmware runs on emulated hardware and its test passes |
| passed | the firmware reports through semihosting, so the result comes from the device |
| passed | without a memory map the firmware does not link at all |
| passed | the link names the section bounds the script was to define |
| passed | and a target that does link locks up at reset, having read no vector table |
| passed | the first word of the image is the initial stack pointer |
| passed | and the second is a reset handler inside flash |
| passed | the runner ends its args with -kernel, and dowel appends the artifact |
| passed | a runner written into dowel.toml is not silently ignored |
| passed | and the failure is about the misplaced table, not about a missing declaration |
| passed | putting the runner back where it belongs makes the tests run again |
| passed | the firmware's debug launch attaches at the declared stub address |
| passed | with the debugger the bare-metal triple declares |
| passed | the stub arguments do not break a runner that ends with the flag taking the artifact |
| passed | because they are inserted before the runner's own arguments, not after them |
| passed | a second build changes nothing |
| passed | editing a peripheral source recompiles it |
| passed | and the image is derived again |
| passed | while its neighbour is left alone |
| passed | the machine flags are declared once, in a template |
| passed | and every target that uses it is compiled with exactly those flags |
| passed | while the link-side template reaches only the two targets that link |
| passed | and the template itself produces nothing, being settings and not a target |
| passed | a target's own values are merged with the template's, not replaced by them |
| passed | with the template's placed first, which is what lets the target win a replace |
| passed | a template may not declare sources, the root block saying what a target is |
| passed | while build itself is untroubled by the templates beside it |
| passed | and so is test |
| passed | the start-up code is built as assembly, not as C that happens to assemble |
| passed | and the C dialect the template declares does not reach it |
| passed | while C still gets it, which is what makes the separation a placement and not a loss |
| passed | while the machine flags do, being what the assembler needs too |
| passed | a preprocessed start-up file records what it includes |
| passed | editing the header it shares with C rebuilds the start-up code |
| passed | and the value it took from that header is the first word of the image |
| passed | the vector table is a symbol the assembly file defines |
| passed | and the reset entry it points at is marked as a thumb function |
| passed | the firmware still runs on emulated hardware with the assembly start-up |
ok apps/dsp — 60 checks (60 passed, 0 failed, 0 known, 0 fixed)
README · cli · core · fw · gui
| state | check |
|---|---|
| passed | the algorithm passes check |
| passed | it builds for the host |
| passed | and for ARM |
| passed | and for RISC-V |
| passed | and for a machine with no operating system |
| passed | the vectors pass on the host |
| passed | and on ARM |
| passed | and on RISC-V |
| passed | and on bare metal, against the same golden header, reported over semihosting |
| passed | the same executable source prints byte-identical numbers on all three |
| passed | the word size is the same on both, so it is not what makes the answers agree |
| passed | but what was built for ARM really is a aarch64 image |
| passed | but what was built for RISC-V really is a RISC-V image |
| passed | but what was built for the host really is a x86-64 image |
| passed | and the bare-metal target also yields the raw image a programmer would take |
| passed | whose ELF form is an ARM image, from the same algorithm source |
| passed | the compiler for aarch64-unknown-linux-gnu is the one its toolchain table named |
| passed | the compiler for riscv64gc-unknown-linux-gnu is the one its toolchain table named |
| passed | the library's own source is compiled freestanding only for the machine that has no libc |
| passed | and is not, for the ones that have it |
| passed | the machine flags the library and its consumer are built with agree, though nothing binds them |
| passed | the packages of this tree name one shared file instead of copying the tables |
| passed | and that file holds the three triples they build for |
| passed | with none of them declaring a toolchain table of its own |
| passed | a consumer naming the file gets the compiler it declares for aarch64-unknown-linux-gnu |
| passed | a consumer naming the file gets the compiler it declares for riscv64gc-unknown-linux-gnu |
| passed | declaring one tool locally leaves the others coming from the file |
| passed | a dependency's toolchain declaration does not reach the build that uses it |
| passed | the error for a missing toolchain mentions the declaration a dependency already carries |
| passed | quoting the value, so the line to write is in front of the reader |
| passed | and why it does not apply, which is what makes the refusal read as a design |
| passed | a consumer builds for a triple its dependency's tests cannot be built for |
| passed | a consumer never builds the dependency's own tests, on a hosted triple either |
| passed | a target outside its triples does not appear in that triple's plan |
| passed | while naming it there is refused, because a build that quietly produces nothing reads as success |
| passed | and on a triple it does declare, the same target builds and runs |
| passed | a consumer that pulls a system library builds against the same algorithm |
| passed | and the algorithm's own translation never sees that library |
| passed | the picture is drawn from the same numbers the other three triples printed |
| passed | and what it wrote has the dimensions it reported |
| passed | with the corner left exactly the declared background colour |
| passed | each triple keeps its own build directory |
| passed | and the archive of the same name differs between them, as it must |
| passed | a second build for one triple runs nothing |
| passed | editing the algorithm recompiles it for the triple being built |
| passed | and leaves the other source alone |
| passed | while another triple is rebuilt only when it is asked for (3 actions) |
| passed | the host build installs |
| passed | and what was installed answers as the build tree's copy did |
| passed | installing for aarch64-unknown-linux-gnu succeeds |
| passed | and what landed there is for that machine, not this one |
| passed | and the installed artifact runs on that machine, out of the prefix alone |
| passed | installing for riscv64gc-unknown-linux-gnu succeeds |
| passed | and what landed there is for that machine, not this one |
| passed | and the installed artifact runs on that machine, out of the prefix alone |
| passed | the distribution for another machine gives the same answers as the host's |
| passed | nothing in this tree needs fetching |
| passed | so the host build runs with the network forbidden |
| passed | and so does the cross build |
| passed | a package that resolves a system library still resolves it offline |
ok apps/hashx — 88 checks (88 passed, 0 failed, 0 known, 0 fixed)
README · ctool · cxxtool · lib
| state | check |
|---|---|
| passed | the library package passes check |
| passed | and builds |
| passed | its own tests pass |
| passed | the artifact is a static archive |
| passed | the C consumer builds against it |
| passed | the C++ consumer builds against it |
| passed | the archive exports exactly the names the header marks as the API |
| passed | and nothing outside the library's own prefix is exported |
| passed | an internal name that must cross translation units is hidden, not exported |
| passed | a new global added without the API mark does not join the exported face |
| passed | a consumer cannot include the library's internal header |
| passed | and removing it builds again |
| passed | the C consumer gets the known answer for the standard check value |
| passed | and the C++ consumer gets the same answer from the same archive |
| passed | the link of the C++ consumer runs through the C++ driver |
| passed | the library names the C ABI boundary rather than its own language |
| passed | and the C++ consumer declares its own language |
| passed | a C++ consumer can declare its own abi label and still use a C library |
| passed | two labels that are not the boundary are still compared |
| passed | and the refusal comes with a diagnostic code and both provenances |
| passed | restoring the boundary label builds again |
| passed | a dependency entry that names two sources is refused |
| passed | and the build does not fall back to the local path |
| passed | the same holds when the two sources are a path and a version |
| passed | removing the second source leaves the package as it was |
| passed | a dependency entry that names no source at all is refused |
| passed | the library takes its version from the manifest instead of repeating it |
| passed | so the public header holds no copy of it |
| passed | and the artifact reports the version the manifest declares |
| passed | moving the manifest version moves what the artifact answers |
| passed | a shared library cannot be declared |
| passed | and the kinds it does offer, which the diagnostic lists, hold nothing for one |
| passed | a build tree offers a foreign consumer nothing, the distribution being what install writes |
| passed | the small-table configuration builds |
| passed | and its tests give the same answers |
| passed | the answer a consumer sees does not depend on how the library was configured |
| passed | a second build of the consumer runs nothing |
| passed | editing a library source recompiles it for the consumer |
| passed | and the consumer is linked again |
| passed | while the library's other translation units are left alone |
| passed | editing the public header recompiles the consumer that includes it |
| passed | the library builds as a shared object |
| passed | producing a shared object where the default configuration produces an archive |
| passed | while the default configuration still produces the archive it always did |
| passed | the names the manifest lists are the ones the object exports |
| passed | and the internal ones are not, so the interface is what was declared |
| passed | a shared library with no exports declared is refused |
| passed | saying why there is no default, which is that the platforms disagree |
| passed | every translation unit inside the shared library is compiled position-independent |
| passed | and is not, when the same library is built as an archive |
| passed | a consumer of the shared library records it as needed at run time |
| passed | and a run-time search path pointing at the build tree's lib directory |
| passed | so it runs straight out of the build tree, without being told where to look |
| passed | and answers exactly what the archive-linked build answers |
| passed | the library's own tests still link when it is built shared |
| passed | while the same tests pass when it is built as an archive |
| passed | and what they reach is an internal name, not something on the public surface |
| passed | and the consumers build and run against the shared object |
| passed | which still sees only what exports lists, because the boundary faces outward |
| passed | a name in exports that the library does not define is refused |
| passed | naming it, and saying which tool was asked |
| passed | and why it matters, which is that the mistake is otherwise invisible until then |
| passed | a shared library may declare its ABI generation |
| passed | which enters the file name |
| passed | and the soname, which is what a consumer records |
| passed | with the plain name left beside it, so linking by -lhashx still works |
| passed | declaring nothing keeps the plain name |
| passed | because when the ABI generation changes is the author's call, not the tool's |
| passed | the library installs into a prefix |
| passed | installing writes lib/libhashx.so |
| passed | installing writes include/hashx/hashx.h |
| passed | installing writes lib/pkgconfig/hashx.pc |
| passed | and keeps the directory shape the header is included through |
| passed | while what is private stays behind |
| passed | the same manifest installs a static distribution too |
| passed | and what lands there is the archive, the feature deciding the form |
| passed | the descriptor carries the one version this package declares |
| passed | and the description, which pkg-config requires of a valid file |
| passed | the descriptor validates as pkg-config input |
| passed | a consumer that never heard of dowel compiles and links against it |
| passed | and the program it produced gives the answers this suite fixed elsewhere |
| passed | a runtime that is neither C nor C++ can load the installed library |
| passed | and gets the same answers, the boundary being an ABI and not a language |
| passed | while a name the library did not export is not reachable from there either |
| passed | and that name does exist in the archive, so the surface was made, not merely absent |
| passed | a consumer builds against the prefix after it is moved and the build tree is gone |
| passed | and what it produced still runs |
| passed | as does loading the moved library from a foreign runtime |
ok apps/httpd — 36 checks (36 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the package passes check |
| passed | it builds |
| passed | the default build asks for nothing beyond the standard library |
| passed | the default configuration compiles the portable waiter |
| passed | and does not compile the one it did not choose |
| passed | choosing the other feature compiles the other waiter |
| passed | a package can declare that its two waiters are exclusive |
| passed | and a package that would end up with two implementations of one interface says so |
| passed | the build does not proceed to pick one silently |
| passed | naming default as the source, which is what --no-default-features drops |
| passed | the epoll configuration builds |
| passed | the default artifact says it is the portable waiter |
| passed | the epoll artifact says so too |
| passed | the threaded configuration asks the linker for threads |
| passed | the threaded configuration builds |
| passed | and its artifact says it is threaded |
| passed | the default configuration builds |
| passed | a request for a file that exists is answered with 200 |
| passed | the response carries the media type the path implies |
| passed | and the body is what the file holds |
| passed | a request for a file that does not exist is answered with 404 |
| passed | a path that climbs out of the root is refused |
| passed | the epoll build answers the same request the same way |
| passed | the unit tests pass |
| passed | and pass under the other waiter too |
| passed | a rebuild of the same configuration is a no-op |
| passed | nothing runs when nothing changed |
| passed | editing the chosen waiter recompiles it |
| passed | and leaves the rest of the library alone |
| passed | the instrumented configuration passes check |
| passed | and builds |
| passed | the instrumentation the library asks for reaches the link of the server |
| passed | the unit tests pass with the instrumentation on |
| passed | a malformed request is answered or refused, never crashes the server |
| passed | the epoll configuration builds instrumented too |
| passed | and the other waiter survives the same requests |
ok apps/jsonfmt — 39 checks (39 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the library package passes check |
| passed | the application package passes check |
| passed | the application builds |
| passed | nothing outside the standard library is linked in |
| passed | the public include directory of the library reaches the application |
| passed | but its private one does not, so the internals stay internal |
| passed | including a private header of the library does not compile |
| passed | and removing it builds again |
| passed | an object is laid out over lines with two spaces |
| passed | -c lays the same object out on one line |
| passed | nesting indents by depth |
| passed | surrounding space is dropped |
| passed | an escaped quote inside a string survives |
| passed | an empty array stays on one line |
| passed | -i sets the width |
| passed | a syntax error is refused with its byte offset |
| passed | the consumer's own tests run and pass |
| passed | and only its own are collected |
| passed | the library's tests run and pass from its own package |
| passed | carrying the label of the package that declares them |
| passed | the test sources live outside the packages that declare them |
| passed | building with a forwarded feature passes |
| passed | the default build has the ordinary depth limit |
| passed | a feature forwarded to a dependency reaches it |
| passed | a forwarded feature does not split the build directory in two |
| passed | the application builds in release |
| passed | a second build of the same configuration runs nothing |
| passed | editing one source recompiles it |
| passed | and does not recompile its neighbours |
| passed | running the tests does not make the next build redo work |
| passed | and a full build leaves nothing for the tests to redo |
| passed | building one target does not make the next full build redo work |
| passed | the instrumented configuration passes check |
| passed | and builds |
| passed | the instrumentation the library asks for reaches the link of the application |
| passed | the tests pass with the instrumentation on |
| passed | hostile input is refused rather than crashing the instrumented build |
| passed | the deep configuration builds with the instrumentation too |
| passed | nesting past the raised limit is refused, not met with a stack overflow |
ok apps/plot — 42 checks (42 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the drawing package passes check |
| passed | and builds |
| passed | its pixel tests pass |
| passed | the default configuration of the shell builds |
| passed | and so does the one that opens a window |
| passed | the system library the drawing package uses reaches the link of the shell |
| passed | but its headers do not, because the dependency was declared private |
| passed | the resolution is written to a lock file |
| passed | and the lock names the package that was resolved |
| passed | with the mechanism that resolved it |
| passed | the configuration that opens no window does not need X11 at run time |
| passed | though it still needs the drawing library it actually uses |
| passed | and the configuration that does open one needs X11 |
| passed | the optional dependency is absent from the plan, not merely unused |
| passed | only the chosen shell is compiled |
| passed | and choosing the other feature compiles the other one |
| passed | the default artifact says which shell it carries |
| passed | and the windowed artifact says the other one |
| passed | a package can declare which of its features are exclusive |
| passed | and asking for both at once is refused |
| passed | the diagnostic says the other one came from default, which is the usual cause |
| passed | dropping the defaults and asking for one builds |
| passed | and exactly one shell is compiled, whichever way the flag goes |
| passed | rendering to a file succeeds |
| passed | the file carries the size that was asked for |
| passed | and the first pixel is exactly the background colour the header declares |
| passed | the body holds one pixel for each pixel of the canvas |
| passed | the windowed build runs against a real X server |
| passed | and it gets as far as putting the image on the window |
| passed | without a display it exits with a status of its own, not a signal |
| passed | and it says what is missing rather than dying inside the library |
| passed | while the other configuration renders with no display at all |
| passed | the instrumented configuration builds |
| passed | and its tests pass |
| passed | awkward sizes and values are refused or drawn, never crash the renderer |
| passed | the windowed configuration builds instrumented too |
| passed | and opening a real window under instrumentation reports nothing |
| passed | the image handed to the server is not read past its own buffer |
| passed | a second build of the same configuration runs nothing |
| passed | editing the drawing source recompiles it |
| passed | and the shell is linked again |
| passed | while its neighbour is left alone |
ok apps/vision — 32 checks (32 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the drawing package passes check |
| passed | and builds |
| passed | the C consumer builds against it |
| passed | every library a large pkg-config package names reaches the link |
| passed | in the order the package gave them, which is what a static link reads |
| passed | and without repeating any of them |
| passed | a second system dependency lands on the same link line |
| passed | the consumer's translation never sees the image library's headers |
| passed | only the one public include directory reaches it |
| passed | the C++ library declares the C ABI boundary, so a C consumer may differ |
| passed | and the link runs through the C++ driver although the consumer is C |
| passed | the C consumer is compiled to the C standard it declared |
| passed | while the C++ library is compiled to its own |
| passed | the artifact needs the graphics library at run time |
| passed | and the parts of the image library it actually calls |
| passed | though far fewer than the flags it was given, because the linker drops the rest |
| passed | a blank render leaves the corner exactly the declared background colour |
| passed | and nothing on it is bright |
| passed | drawing a triangle marks some of the image but not all of it |
| passed | and the corner stays background, because a triangle does not reach it |
| passed | the size asked for is the size rendered |
| passed | raising the threshold never counts more pixels, so the count is really measured |
| passed | the library's own cases all pass |
| passed | the instrumented configuration builds |
| passed | and the library's cases pass under it |
| passed | the same binary reports leaks when the suppressions the manifest named are withheld |
| passed | and what it suppresses is one named library, not leak detection itself |
| passed | awkward sizes and thresholds are refused or rendered, never crash |
| passed | a second build of the consumer runs nothing |
| passed | editing the analysis source recompiles it |
| passed | and leaves the drawing source alone, though both use the same big library |
| passed | while the consumer is linked again |
ok apps/winapp — 38 checks (38 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | the package passes check |
| passed | it builds for the host |
| passed | and its cases pass there |
| passed | the host build reports the host's line ending and separator |
| passed | the same package builds for Windows |
| passed | the Windows implementation is the one translated, and only it |
| passed | while the portable source is shared, not duplicated per target |
| passed | and the compiler is the one the triple's toolchain table named |
| passed | the Windows build really produces an executable |
| passed | the artifact dowel names is the file that was written |
| passed | and the suffix follows the target, so the host build keeps none |
| passed | run under wine by hand, the Windows build reports CRLF |
| passed | and the Windows path separator |
| passed | and a value only the Win32 API could have given it |
| passed | a path mixing both separators is split the way Windows splits it |
| passed | and a bare LF is normalised to the Windows line ending |
| passed | and a Windows target can be tested through its runner |
| passed | with each declared case launched in its own right |
| passed | a manifest may name cl as the compiler for the MSVC triple |
| passed | an MSVC toolchain can be declared, not just named |
| passed | without asking for a dependency record in a spelling that means the dynamic CRT there |
| passed | using the spelling that does mean it under this style |
| passed | and the link runs through a separate program, as that toolchain has it |
| passed | with the object and output spellings that toolchain writes |
| passed | while the GNU family still gets the spelling that is correct for it |
| passed | a manifest can select sources by the target's operating system |
| passed | and that key has a finite domain, so a match on it is checked for exhaustiveness |
| passed | which is how this application actually spells the choice |
| passed | and it selects the Windows implementation when the target is Windows |
| passed | while host.os still means the build machine, so the pair is complete |
| passed | the two targets keep separate build directories |
| passed | and what the Windows directory holds is a Windows executable |
| passed | while the host directory holds an ELF one, from the same sources |
| passed | a second Windows build runs nothing |
| passed | while a second host build of the same tree runs nothing |
| passed | editing the Windows implementation recompiles it |
| passed | and leaves the portable source alone |
| passed | and the host build is untouched by it, because it never used that source |
ok projects/docs — 9 checks (9 passed, 0 failed, 0 known, 0 fixed)
| state | check |
|---|---|
| passed | every relative link in the documentation resolves |
| passed | the project table in README.md matches projects/ |
| passed | the application table in README.md matches apps/ |
| passed | the documentation table in README.md matches docs/ |
| passed | check names quoted in the documentation exist |
| passed | every known_issue declaration names a finding that exists |
| passed | the index of docs/10-findings.md matches its sections |
| passed | README embeds the history chart the publication branch generates |
| passed | the dowel revision quoted in the documentation matches dowel-ref |
Growth
How the suite grew, run by run. The top plot is the total, split by where the checks live; the bottom grid is one plot per layer on a shared scale, so both the arrival of a layer and its size are visible. Every number here is also a row of the table below.
History
Each cell is passed / failed / known / fixed for that project. A dash means the project did not exist at that point.
| run | state | branch | commit | dowel | 01-minimal | 02-config | 03-features | 04-diagnostics | 05-incremental | 06-runner | 07-robustness | 08-lsp | 09-acquisition | 10-toolchain | 11-cross | 12-store | 13-parallel | 14-scale | 15-cpp | 16-migrate | 17-deps | 18-tools | 19-artifacts | 20-cases | 21-debug | 22-bench | 23-probe | 24-install | 25-asm | 26-prebuilt | 27-generate | 28-progress | 29-tool-identity | blink | docs | dsp | hashx | httpd | jsonfmt | plot | vision | winapp | total |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2026-09-02T16:25:11Z | ok | main | 316882ed4e11 | 7512e7639fc7 | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 40/0/0/0 | 145/0/0/0 | 110/0/0/0 | 120/0/1/0 | 53/0/0/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 87/0/0/0 | 83/0/0/0 | 33/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 55/0/0/0 | 53/0/0/0 | 28/0/0/0 | 55/0/6/0 | 19/0/0/0 | 21/0/0/0 | 59/0/0/0 | 9/0/0/0 | 60/0/0/0 | 88/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1867 |
| 2026-09-02T13:11:50Z | ok | main | 71f7513b7f8f | f65fe20a974f | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 40/0/0/0 | 145/0/0/0 | 110/0/0/0 | 120/0/1/0 | 53/0/0/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 87/0/0/0 | 83/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 48/0/0/0 | 52/0/1/0 | 28/0/0/0 | — | — | — | 59/0/0/0 | 9/0/0/0 | 60/0/0/0 | 88/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1758 |
| 2026-08-21T08:04:45Z | ok | main | 0bcb1ba979f2 | f65fe20a974f | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 40/0/0/0 | 145/0/0/0 | 110/0/0/0 | 120/0/1/0 | 53/0/0/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 87/0/0/0 | 83/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 48/0/0/0 | 52/0/1/0 | 28/0/0/0 | — | — | — | 59/0/0/0 | 9/0/0/0 | 60/0/0/0 | 88/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1758 |
| 2026-08-21T04:17:16Z | ok | main | cf71c393760e | f65fe20a974f | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 40/0/0/0 | 145/0/0/0 | 110/0/0/0 | 120/0/1/0 | 53/0/0/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 87/0/0/0 | 83/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 48/0/0/0 | 52/0/1/0 | 28/0/0/0 | — | — | — | 59/0/0/0 | 9/0/0/0 | 60/0/0/0 | 88/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1758 |
| 2026-08-15T05:08:39Z | ok | main | cc126d0cde3d | 0511d5e048bc | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 34/0/2/0 | 145/0/0/0 | 110/0/0/0 | 107/0/1/0 | 50/0/2/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 72/0/0/0 | 83/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 44/0/2/0 | 23/0/3/0 | 26/0/1/0 | — | — | — | 59/0/0/0 | 9/0/0/0 | 60/0/0/0 | 88/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1695 |
| 2026-08-14T02:10:27Z | ok | main | 44b9e82bb372 | 0511d5e048bc | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 94/0/0/0 | 49/0/0/0 | 34/0/2/0 | 145/0/0/0 | 110/0/0/0 | 107/0/1/0 | 50/0/2/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 72/0/0/0 | 83/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | 44/0/2/0 | 23/0/3/0 | 26/0/1/0 | — | — | — | 48/0/0/0 | 9/0/0/0 | 47/0/0/0 | 68/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1651 |
| 2026-08-12T07:20:11Z | ok | main | 6bdf4c361082 | c1540974ad02 | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 80/0/1/0 | 49/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 91/0/4/0 | 31/0/0/0 | 17/0/0/0 | 43/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 72/0/0/0 | 67/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | — | — | — | — | — | — | 47/0/1/0 | 9/0/0/0 | 47/0/0/0 | 68/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1470 |
| 2026-08-12T00:12:39Z | ok | main | e30f89612834 | 98589323fbb6 | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 75/0/0/0 | 49/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 66/0/2/0 | 67/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | — | — | — | — | — | — | 39/0/0/0 | 9/0/0/0 | 42/0/0/0 | 56/0/1/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1393 |
| 2026-08-11T23:51:50Z | ok | main | 11d5f9f074a6 | 98589323fbb6 | 10/0/0/0 | 34/0/0/0 | 17/0/0/0 | 75/0/0/0 | 49/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 66/0/2/0 | 67/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | 34/0/0/0 | 23/0/0/0 | — | — | — | — | — | — | 39/0/0/0 | 9/0/0/0 | 42/0/0/0 | 56/0/1/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1393 |
| 2026-08-11T14:53:32Z | ok | main | a2af59ce8504 | 98589323fbb6 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 75/0/0/0 | 49/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 62/0/0/0 | 32/0/0/0 | — | — | — | — | — | — | — | — | 39/0/0/0 | 9/0/0/0 | 42/0/0/0 | 41/0/0/0 | 36/0/0/0 | 39/0/0/0 | 42/0/0/0 | 32/0/0/0 | 38/0/0/0 | 1277 |
| 2026-08-11T10:00:09Z | ok | main | 78c5d1a0fd71 | e12bac762dfd | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/4/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 59/0/1/0 | 26/0/2/0 | — | — | — | — | — | — | — | — | 37/0/1/0 | 9/0/0/0 | 36/0/2/0 | 41/0/0/0 | 36/0/0/0 | 37/0/0/0 | 42/0/0/0 | 32/0/0/0 | 25/0/5/0 | 1254 |
| 2026-08-11T02:45:33Z | ok | main | e0afaf9fb4a3 | e12bac762dfd | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/4/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 59/0/1/0 | 26/0/2/0 | — | — | — | — | — | — | — | — | 37/0/1/0 | 9/0/0/0 | — | 41/0/0/0 | 36/0/0/0 | 37/0/0/0 | 42/0/0/0 | 32/0/0/0 | 25/0/5/0 | 1216 |
| 2026-08-11T01:29:09Z | ok | main | bc08c280c290 | e12bac762dfd | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 59/0/1/0 | 26/0/2/0 | — | — | — | — | — | — | — | — | 37/0/1/0 | 9/0/0/0 | — | 41/0/0/0 | 36/0/0/0 | 37/0/0/0 | 42/0/0/0 | — | — | 1146 |
| 2026-08-10T23:18:19Z | ok | main | 85f8b798a8d3 | e12bac762dfd | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 59/0/1/0 | 26/0/2/0 | — | — | — | — | — | — | — | — | 37/0/1/0 | 8/0/0/0 | — | 41/0/0/0 | 36/0/0/0 | 37/0/0/0 | 42/0/0/0 | — | — | 1145 |
| 2026-08-10T14:15:51Z | ok | main | 3751aa5f6672 | 17bd54e090b1 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 32/0/0/0 | 35/0/0/0 | 29/0/17/0 | — | — | — | — | — | — | — | — | — | 35/0/0/0 | 8/0/0/0 | — | 41/0/0/0 | 36/0/0/0 | 37/0/0/0 | 42/0/0/0 | — | — | 1100 |
| 2026-08-07T03:48:35Z | ok | main | 7660d8f3dc1a | af7d391f1e22 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 31/0/1/0 | 34/0/1/0 | — | — | — | — | — | — | — | — | — | — | 32/0/4/0 | 8/0/0/0 | — | 34/0/4/0 | 36/0/1/0 | 34/0/3/0 | 41/0/1/0 | — | — | 1053 |
| 2026-08-06T12:30:58Z | ok | main | fb4d394e090c | af7d391f1e22 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 31/0/1/0 | 34/0/1/0 | — | — | — | — | — | — | — | — | — | — | 32/0/4/0 | 8/0/0/0 | — | — | 33/0/0/0 | 34/0/3/0 | — | — | — | 969 |
| 2026-08-05T10:30:54Z | ok | main | cf2888d5f0d9 | af7d391f1e22 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 31/0/1/0 | 34/0/1/0 | — | — | — | — | — | — | — | — | — | — | — | 8/0/0/0 | — | — | 26/0/0/0 | 27/0/3/0 | — | — | — | 919 |
| 2026-08-05T03:57:00Z | ok | main | 878cdb8a2075 | af7d391f1e22 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 54/0/0/0 | 51/0/0/0 | 31/0/1/0 | 34/0/1/0 | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 862 |
| 2026-08-03T03:54:38Z | ok | main | 8fb90df15f92 | a9c16191bb0f | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | 53/0/1/0 | 48/0/2/0 | 27/0/6/0 | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 827 |
| 2026-08-03T00:12:52Z | ok | main | 9bb5ceb209d1 | 2e99fc718f45 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 110/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/2/0 | 46/0/3/0 | 48/0/2/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 791 |
| 2026-07-30T16:25:58Z | ok | main | 49808ac5de0a | 3e84cbdddb72 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 48/0/0/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 17/0/0/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/2/0 | 46/0/3/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 728 |
| 2026-07-30T03:58:37Z | ok | main | 314500155dc9 | 9ed13f484703 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/2/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 676 |
| 2026-07-30T03:44:54Z | ok | main | 4546a243874a | 9ed13f484703 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 70/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 674 |
| 2026-07-30T00:26:10Z | ok | main | 658861eadf3a | 9ed13f484703 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 66/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | 35/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 639 |
| 2026-07-29T16:10:49Z | ok | main | c77f4253144a | 95daf9ff8dac | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | 29/0/0/0 | 18/0/0/0 | 17/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 608 |
| 2026-07-29T15:59:52Z | ok | main | a8de02c1ad51 | 95daf9ff8dac | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | 29/0/0/0 | 18/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 591 |
| 2026-07-29T15:41:23Z | ok | main | 986b5f773b5b | 95daf9ff8dac | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 47/0/1/0 | 17/0/0/0 | 145/0/0/0 | 97/0/0/0 | 66/0/1/0 | 31/0/0/0 | 12/0/2/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 544 |
| 2026-07-29T14:46:56Z | ok | main | b1380dd21bfe | 19a4a409f6e8 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 44/0/0/0 | 17/0/0/0 | 118/0/12/0 | 88/0/9/0 | 62/0/3/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 478 |
| 2026-07-29T12:49:06Z | ok | main | f572f6c393f4 | 07f16ec59e48 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 44/0/0/0 | 17/0/0/0 | 118/0/12/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 316 |
| 2026-07-29T00:28:01Z | ok | main | 83dc45bb1fbd | 07f16ec59e48 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 70/0/0/0 | 44/0/0/0 | 17/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 186 |
| 2026-07-28T14:57:38Z | ok | main | 0c03829f1951 | 07f16ec59e48 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 64/0/0/0 | 44/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 7/0/0/0 | — | — | — | — | — | — | — | 163 |
| 2026-07-28T14:45:50Z | ok | main | 23244295550f | 07f16ec59e48 | 10/0/0/0 | 21/0/0/0 | 17/0/0/0 | 64/0/0/0 | 44/0/0/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 156 |
| 2026-07-28T13:32:14Z | ok | main | b69cc8fe3796 | a8a59e7c70aa | 10/0/0/0 | 21/0/0/0 | 12/0/4/0 | 37/0/10/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 94 |
| 2026-07-28T13:10:49Z | ok | main | 8523cf675458 | a8a59e7c70aa | 10/0/0/0 | 21/0/0/0 | 12/0/4/0 | 37/0/10/0 | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | — | 94 |