Index

Modules: balls, balls/runner, balls/semaphores, balls/spec, balls/style, balls/tabouli.

API symbols

`$`:

• style: proc `$`(style: Styling): string

`&`:

• style: proc `&`(a: string; b: Styling): Styling
• style: proc `&`(style: Styling; n: NimNode): NimNode
• style: proc `&`(a: Styling; b: string): Styling
• style: proc `&`(a, b: Styling): Styling

`<`:

• runner: proc `<`(a, b: Profile): bool

`==`:

• runner: proc `==`(a, b: Profile): bool

`=copy`:

• semaphores: proc `=copy`(s: var Semaphore; e: Semaphore)

`=destroy`:

• semaphores: proc `=destroy`(s: var Semaphore)

acquire:

• semaphores: proc acquire(s: var Semaphore)

Analyzer:

• runner: enum Analyzer

arc:

• runner: MemModel.arc

ASanitizer:

• runner: Analyzer.ASanitizer

available:

• semaphores: proc available(s: var Semaphore): int

Backend:

• runner: enum Backend

ballsDry:

• spec: const ballsDry

ballsFailFast:

• runner: const ballsFailFast

c:

• runner: Backend.c

check:

• balls: macro check(body: bool; message: string = "")
• balls: macro check(message: string; body: untyped)

checkpoint:

• balls: proc checkpoint(ss: varargs[string, `$`])

cmp:

• runner: proc cmp(a, b: Profile): int

commandLine:

• runner: proc commandLine(p: Profile; withHints = false): string

commentStyle:

• style: const commentStyle

contains:

• runner: proc contains(matrix: Matrix; p: Profile): bool

cpp:

• runner: Backend.cpp

danger:

• runner: Optimizer.danger

DataRacer:

• runner: Analyzer.DataRacer

debug:

• runner: Optimizer.debug

dec:

• semaphores: proc dec(s: var Semaphore)

Died:

• spec: StatusKind.Died

dollar:

• spec: proc dollar(n: NimNode): NimNode

e:

• runner: Backend.e

emojiSource:

• spec: const emojiSource

emojiStack:

• spec: const emojiStack

exceptionStyle:

• style: const exceptionStyle

Execution:

• runner: Analyzer.Execution

expect:

• balls: template expect(exception: typed; body: untyped)

ExpectedError:

• spec: object ExpectedError

fail:

• balls: proc fail(msg = "failed")

Fail:

• spec: StatusKind.Fail

FailError:

• spec: object FailError

failureStyle:

• style: const failureStyle

flushStreams:

• spec: proc flushStreams()

hasDefects:

• spec: const hasDefects

hash:

• runner: proc hash(p: Profile): Hash
• semaphores: proc hash(s: var Semaphore): Hash

hasPanics:

• spec: const hasPanics

headerStyle:

• style: const headerStyle

Helgrind:

• runner: Analyzer.Helgrind

hints:

• runner: proc hints(p: Profile; ci: bool): string

inc:

• semaphores: proc inc(s: var Semaphore)

Info:

• spec: StatusKind.Info

informStyle:

• style: const informStyle

init:

• spec: proc init(test: var Test; name: string; code: NimNode)

initSemaphore:

• semaphores: proc initSemaphore(s: var Semaphore; count: int = 0)

isReady:

• semaphores: template isReady(s: var Semaphore): untyped

js:

• runner: Backend.js

leaderStyle:

• style: const leaderStyle

lineNumStyle:

• style: const lineNumStyle

main:

• runner: proc main(directory: string; fallback = false)

markAndSweep:

• runner: MemModel.markAndSweep

Matrix:

• runner: type Matrix

matrixTable:

• runner: proc matrixTable(matrix: Matrix): string

MemModel:

• runner: enum MemModel

noclobber:

• spec: template noclobber(body: untyped)

None:

• spec: StatusKind.None

onCI:

• spec: const onCI

Oops:

• spec: StatusKind.Oops

oopsStyle:

• style: const oopsStyle

Optimizer:

• runner: enum Optimizer

orc:

• runner: MemModel.orc

ordered:

• runner: proc ordered(directory: string; testsOnly = true): seq[string]

Part:

• spec: StatusKind.Part

partialStyle:

• style: const partialStyle

Pass:

• spec: StatusKind.Pass

perform:

• runner: proc perform(matrix: var Matrix; profs: seq[Profile])
• runner: proc perform(p: Profile): StatusKind

Profile:

• runner: object Profile

profiles:

• runner: proc profiles(fn: string): seq[Profile]

refc:

• runner: MemModel.refc

release:

• runner: Optimizer.release
• semaphores: proc release(s: var Semaphore)

render:

• tabouli: proc render(t: Tabouli; size = 1): string

report:

• balls: macro report(ss: varargs[typed])

resetStyle:

• style: const resetStyle

resultsStyle:

• style: const resultsStyle

Runs:

• spec: StatusKind.Runs

Semaphore:

• semaphores: object Semaphore

setBallsResult:

• spec: proc setBallsResult(q: int)

signal:

• semaphores: proc signal(s: var Semaphore)

skip:

• balls: proc skip(msg = "skipped")
• balls: template skip(msg = "skipped"; body: untyped)

Skip:

• spec: StatusKind.Skip

SkipError:

• spec: object SkipError

skippedStyle:

• style: const skippedStyle

sourceStyle:

• style: const sourceStyle

StatusKind:

• spec: enum StatusKind

statusStyles:

• style: const statusStyles

Styling:

• style: type Styling

successStyle:

• style: const successStyle

suite:

• balls: macro suite(name: string; tests: untyped)

Tabouli:

• tabouli: object Tabouli

test:

• balls: macro test(name: string; body: untyped)

Test:

• spec: object Test

testable:

• spec: const testable

totalTests:

• spec: proc totalTests(): int

TSanitizer:

• runner: Analyzer.TSanitizer

useColor:

• style: proc useColor(): bool

Valgrind:

• runner: Analyzer.Valgrind

viaFileStyle:

• style: const viaFileStyle

viaProcStyle:

• style: const viaProcStyle

vm:

• runner: MemModel.vm

wait:

• semaphores: proc wait(s: var Semaphore)

Wait:

• spec: StatusKind.Wait

withLock:

• semaphores: template withLock(s: var Semaphore; logic: untyped)

withSemaphore:

• semaphores: template withSemaphore(s: var Semaphore; logic: typed): untyped