Dagger
Search

tests

is exposed as a standalone dagger function so it can be invoked individually
during TDD; All wires them up for parallel execution under `dagger call all`.

Installation

dagger install github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453

Entrypoint

Return Type 
Tests
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \

func (m *MyModule) Example() *dagger.Tests  {
	return dag.
			Tests()
}
@function
def example() -> dagger.Tests:
	return (
		dag.tests()
	)
@func()
example(): Tests {
	return dag
		.tests()
}

Types

Tests 🔗

all() 🔗

All runs every zig-module test in parallel.

parallel caps how many tests run concurrently inside this suite. Defaults to 0 (unbounded fan-out) — each dagger check job runs on its own GH Actions runner, so in-runner parallelism is bounded by the VM’s CPU/memory, not by the scheduler. Pass any positive integer to opt into a specific cap.

Return Type 
Void !
Arguments
NameTypeDefault ValueDescription
parallelInteger !0No description provided
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 all --parallel integer
func (m *MyModule) Example(ctx context.Context, parallel int)   {
	return dag.
			Tests().
			All(ctx, parallel)
}
@function
async def example(parallel: int) -> None:
	return await (
		dag.tests()
		.all(parallel)
	)
@func()
async example(parallel: number): Promise<void> {
	return dag
		.tests()
		.all(parallel)
}

buildCrossTargetProducesBinary() 🔗

BuildCrossTargetProducesBinary cross-compiles the hello fixture for aarch64-linux and asserts an artifact is produced. The binary is not host-runnable, so only its size is checked.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-cross-target-produces-binary
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildcrosstargetproducesbinary(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildcrosstargetproducesbinary()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildCrossTargetProducesBinary()
}

buildExeProducesExecutable() 🔗

BuildExeProducesExecutable builds the single-file fixture via build-exe and asserts the produced file is named “main” and non-empty.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-exe-produces-executable
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildexeproducesexecutable(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildexeproducesexecutable()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildExeProducesExecutable()
}

buildExeRejectsEmptyRoot() 🔗

BuildExeRejectsEmptyRoot asserts BuildExe rejects an empty root. BuildExe returns a lazy file, so the error surfaces on resolve.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-exe-rejects-empty-root
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildexerejectsemptyroot(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildexerejectsemptyroot()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildExeRejectsEmptyRoot()
}

buildHelloProducesBinary() 🔗

BuildHelloProducesBinary builds the hello fixture for the host and asserts the installed executable (zig-out/bin/hello) is non-empty.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-hello-produces-binary
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildhelloproducesbinary(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildhelloproducesbinary()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildHelloProducesBinary()
}

buildOptimizeReleaseSmall() 🔗

BuildOptimizeReleaseSmall builds the hello fixture with -Doptimize=ReleaseSmall and asserts an executable is produced.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-optimize-release-small
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildoptimizereleasesmall(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildoptimizereleasesmall()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildOptimizeReleaseSmall()
}

buildRejectsInvalidOptimize() 🔗

BuildRejectsInvalidOptimize asserts Build rejects an invalid optimize value. Build returns a lazy directory, so the validation error surfaces on resolve.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 build-rejects-invalid-optimize
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Buildrejectsinvalidoptimize(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.buildrejectsinvalidoptimize()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.buildRejectsInvalidOptimize()
}

ccCompilesHelloC() 🔗

CcCompilesHelloC compiles the C fixture for the host with zig cc and asserts the produced artifact is non-empty.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 cc-compiles-hello-c
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cccompileshelloc(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cccompileshelloc()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ccCompilesHelloC()
}

ccCrossWindowsProducesExe() 🔗

CcCrossWindowsProducesExe cross-compiles the C fixture for x86_64-windows-gnu and asserts the artifact carries the requested output name. Resolving .Name runs the cross-compile, so a successful Name read also proves the cross build succeeded.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 cc-cross-windows-produces-exe
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cccrosswindowsproducesexe(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cccrosswindowsproducesexe()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ccCrossWindowsProducesExe()
}

ccRejectsEmptyFiles() 🔗

CcRejectsEmptyFiles asserts Cc rejects an empty files slice. Cc returns a lazy file, so the validation error surfaces on resolve.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 cc-rejects-empty-files
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Ccrejectsemptyfiles(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.ccrejectsemptyfiles()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ccRejectsEmptyFiles()
}

ccRejectsPathOutputName() 🔗

CcRejectsPathOutputName asserts Cc rejects a path-like outputName (the parameter is a bare filename, not a path). The validation error surfaces on resolve, before any zig exec runs.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 cc-rejects-path-output-name
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Ccrejectspathoutputname(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.ccrejectspathoutputname()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ccRejectsPathOutputName()
}

ciCheckRunsChecksAndSkipsBuild() 🔗

CiCheckRunsChecksAndSkipsBuild configures every stage against the clean hello fixture and calls Check (not Run), asserting no error. To actively prove Check does not invoke the build stage, WithBuild is configured with a nonexistent build step: if Check were to call runBuild, zig build nonexistent-step would fail and surface here. A nil return therefore proves both (a) the checks passed and (b) the build was skipped.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 ci-check-runs-checks-and-skips-build
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cicheckrunschecksandskipsbuild(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cicheckrunschecksandskipsbuild()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ciCheckRunsChecksAndSkipsBuild()
}

ciRunAggregatesFailures() 🔗

CiRunAggregatesFailures runs Ci against the ci-bad fixture with both Fmt and Test enabled and asserts stage-1 aggregated BOTH job failures rather than short-circuiting on the first. Fmt fails with the “unformatted files” message and Test fails with a withExec “exit code” error; the parallel aggregator concatenates both, so requiring both signatures in the message proves both jobs ran and both errors propagated (and the build was skipped).

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 ci-run-aggregates-failures
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cirunaggregatesfailures(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cirunaggregatesfailures()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ciRunAggregatesFailures()
}

ciRunAllStagesProducesBinary() 🔗

CiRunAllStagesProducesBinary runs Ci with every stage enabled against the hello fixture and asserts a non-empty binary is produced.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 ci-run-all-stages-produces-binary
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cirunallstagesproducesbinary(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cirunallstagesproducesbinary()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ciRunAllStagesProducesBinary()
}

ciWithFmtPasses() 🔗

CiWithFmtPasses runs Ci with only the Fmt check enabled against the fmt-clean hello fixture and asserts the build stage still produces a non-empty binary.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 ci-with-fmt-passes
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Ciwithfmtpasses(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.ciwithfmtpasses()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ciWithFmtPasses()
}

ciWithTestPasses() 🔗

CiWithTestPasses runs Ci with only the Test check enabled (zig build test) against the hello fixture and asserts a non-empty binary is produced.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 ci-with-test-passes
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Ciwithtestpasses(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.ciwithtestpasses()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.ciWithTestPasses()
}

containerHasZigToolchain() 🔗

ContainerHasZigToolchain proves the base container is reachable, the downloaded toolchain is on PATH, the source is mounted at /src, and zig runs. This is the canary for every other test — if it fails, the rest can’t possibly pass.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 container-has-zig-toolchain
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Containerhaszigtoolchain(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.containerhaszigtoolchain()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.containerHasZigToolchain()
}

containerInfersVersionFromZon() 🔗

ContainerInfersVersionFromZon asserts that constructing the module with New(“”) and a fixture whose build.zig.zon declares minimum_zig_version = zonVersion actually downloads the matching toolchain — i.e. resolveVersion + ZON parsing wire through to toolchain selection. zonVersion is a different patch than the pinned default, so a match proves inference rather than the fallback.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 container-infers-version-from-zon
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Containerinfersversionfromzon(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.containerinfersversionfromzon()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.containerInfersVersionFromZon()
}

cxxCompilesHelloCpp() 🔗

CxxCompilesHelloCpp compiles the C++ fixture for the host with zig c++ and asserts the produced artifact is non-empty.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 cxx-compiles-hello-cpp
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Cxxcompileshellocpp(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.cxxcompileshellocpp()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.cxxCompilesHelloCpp()
}

envContainsVersionKey() 🔗

EnvContainsVersionKey calls the source-less Env and asserts the zig env JSON contains the version key.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 env-contains-version-key
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Envcontainsversionkey(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.envcontainsversionkey()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.envContainsVersionKey()
}

fmtHelloIsClean() 🔗

FmtHelloIsClean runs Fmt against the fmt-clean hello fixture and asserts no error is returned.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 fmt-hello-is-clean
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Fmthelloisclean(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.fmthelloisclean()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.fmtHelloIsClean()
}

fmtUnformattedReportsFile() 🔗

FmtUnformattedReportsFile runs Fmt against the unformatted fixture and asserts it returns an error naming the offending file. Fmt surfaces the offending paths only via the error (it returns error alone, since a Dagger function’s non-error return value is dropped at the GraphQL boundary when it also returns a non-nil error).

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 fmt-unformatted-reports-file
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Fmtunformattedreportsfile(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.fmtunformattedreportsfile()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.fmtUnformattedReportsFile()
}

objCopyProducesBinary() 🔗

ObjCopyProducesBinary converts the BuildExe ELF to a raw .bin and asserts the result is non-empty and no longer carries the ELF magic.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 obj-copy-produces-binary
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Objcopyproducesbinary(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.objcopyproducesbinary()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.objCopyProducesBinary()
}

objCopyProducesIntelHex() 🔗

ObjCopyProducesIntelHex converts the BuildExe ELF to Intel HEX and asserts the first record begins with ‘:’ (the Intel HEX record start code).

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 obj-copy-produces-intel-hex
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Objcopyproducesintelhex(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.objcopyproducesintelhex()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.objCopyProducesIntelHex()
}

objCopyRejectsUnknownFormat() 🔗

ObjCopyRejectsUnknownFormat asserts ObjCopy rejects an unsupported format (e.g. “uf2”). ObjCopy returns a lazy file, so the error surfaces on resolve.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 obj-copy-rejects-unknown-format
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Objcopyrejectsunknownformat(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.objcopyrejectsunknownformat()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.objCopyRejectsUnknownFormat()
}

runHelloPrintsHello() 🔗

RunHelloPrintsHello runs the hello fixture and asserts its stdout contains “hello”.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 run-hello-prints-hello
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Runhelloprintshello(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.runhelloprintshello()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.runHelloPrintsHello()
}

sizeRejectsNonElf() 🔗

SizeRejectsNonElf feeds a raw .bin (produced by ObjCopy) into Size and asserts a clear non-ELF error.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 size-rejects-non-elf
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Sizerejectsnonelf(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.sizerejectsnonelf()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.sizeRejectsNonElf()
}

sizeReportsSections() 🔗

SizeReportsSections asserts Size on the BuildExe host ELF returns Text > 0 and internally consistent Flash/Ram rollups.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 size-reports-sections
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Sizereportssections(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.sizereportssections()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.sizeReportsSections()
}

targetsListsKnownArch() 🔗

TargetsListsKnownArch calls the source-less Targets and asserts a known architecture appears in the output.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 targets-lists-known-arch
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Targetslistsknownarch(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.targetslistsknownarch()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.targetsListsKnownArch()
}

testDirectFilePasses() 🔗

TestDirectFilePasses runs zig test main.zig against the single-file fixture and asserts it succeeds.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 test-direct-file-passes
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Testdirectfilepasses(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.testdirectfilepasses()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.testDirectFilePasses()
}

testHelloBuildStepPasses() 🔗

TestHelloBuildStepPasses runs zig build test against the hello fixture and asserts it succeeds.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 test-hello-build-step-passes
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Testhellobuildsteppasses(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.testhellobuildsteppasses()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.testHelloBuildStepPasses()
}

toolVersionReturnsVersion() 🔗

ToolVersionReturnsVersion calls the source-less ToolVersion and asserts it returns a dotted version string.

Return Type 
Void !
Example
dagger -m github.com/z5labs/devex/daggerverse/zig/tests@a17bf411228ae3d544c7c18bcf08dd04c295d453 call \
 tool-version-returns-version
func (m *MyModule) Example(ctx context.Context)   {
	return dag.
			Tests().
			Toolversionreturnsversion(ctx)
}
@function
async def example() -> None:
	return await (
		dag.tests()
		.toolversionreturnsversion()
	)
@func()
async example(): Promise<void> {
	return dag
		.tests()
		.toolVersionReturnsVersion()
}