Index

Modules: npbt/arbitraries_core, npbt/pbt_types, npbt/pbt_types_execution, npbt/propertytest.

API symbols

`$`:

• pbt_types_execution: `$`[T](r: AssertReport[T]): string
• pbt_types_execution: `$`[T](r: RunExecution[T]): string

akExhaustive:

• ArbitraryKind.akExhaustive

akLarge:

• ArbitraryKind.akLarge

arbChar:

• arbitraries_core: arbChar(): Arbitrary[char]
• arbitraries_core: arbChar(min, max: char): Arbitrary[char]
• arbitraries_core: arbChar(chars: set[char]): Arbitrary[char]

arbCharAscii:

• arbitraries_core: arbCharAscii(): Arbitrary[char]

arbEnum:

• arbitraries_core: arbEnum[T: enum](values: set[T] = {low(T) .. high(T)}): Arbitrary[T]

arbInt:

• arbitraries_core: arbInt(): Arbitrary[int]
• arbitraries_core: arbInt(min, max: int): Arbitrary[int]

Arbitrary:

• pbt_types: Arbitrary

arbitrary:

• pbt_types: arbitrary[T](mgenerate: ArbitraryImpl[T]; shrink: ShrinkImpl[T] = nil; kind: ArbitraryKind = akLarge): Arbitrary[T]

ArbitraryImpl:

• pbt_types: ArbitraryImpl

ArbitraryKind:

• pbt_types: ArbitraryKind

arbNimNode:

• arbitraries_core: arbNimNode(): Arbitrary[NimNode]

arbRune:

• arbitraries_core: arbRune(): Arbitrary[Rune]

arbSample:

• arbitraries_core: arbSample[T](values: seq[T]): Arbitrary[T]

arbSeq:

• arbitraries_core: arbSeq[A](itemArb: Arbitrary[A]; minLen: Natural; maxLen: Natural; flags: set[ CollectionGenFlags] = {cgfAllowRepeat, cgfSequentialRepeat}): Arbitrary[ seq[A]]

arbSeqOf:

• arbitraries_core: arbSeqOf[T](a: Arbitrary[T]; min: uint32 = 0; max: uint32 = 100): Arbitrary[ seq[T]]

arbString:

• arbitraries_core: arbString(min: uint32 = 0; max: uint32 = 1000; arbchar = arbChar()): Arbitrary[ string]

arbStringAscii:

• arbitraries_core: arbStringAscii(min: uint32 = 0; max: uint32 = 1000): Arbitrary[string]

arbStringNimIdent:

• arbitraries_core: arbStringNimIdent(idLen: int = 12; repeatNormalized: bool = false; useUnicode: bool = false): Arbitrary[string]

arbTuple:

• arbitraries_core: arbTuple[A](a1: Arbitrary[A]): Arbitrary[(A,)]
• arbitraries_core: arbTuple[A, B](a1: Arbitrary[A]; a2: Arbitrary[B]): Arbitrary[(A, B)]

arbuint32:

• arbitraries_core: arbuint32(): Arbitrary[uint32]
• arbitraries_core: arbuint32(min, max: uint32): Arbitrary[uint32]

AssertParams:

• pbt_types_execution: AssertParams

AssertReport:

• pbt_types_execution: AssertReport

asShrinkable:

• pbt_types: asShrinkable[T](v: sink T): Shrinkable[T]

asStatus:

• pbt_types: asStatus(b: bool): PTStatus

cgfRepeatEnableKinds:

• arbitraries_core: cgfRepeatEnableKinds

cgfRepeatOrderKinds:

• arbitraries_core: cgfRepeatOrderKinds

ctSpec:

• propertytest: ctSpec(n: string = ""; body: untyped): untyped

ctxEcho:

• pbt_types_execution: ctxEcho(ctx: GlobalContext; msg: string)

defAssertPropParams:

• pbt_types_execution: defAssertPropParams(): AssertParams

execAndShrink:

• pbt_types_execution: execAndShrink[T](ctx: var GlobalContext; value: Shrinkable[T]; prop: Property[T]; params: AssertParams = defAssertPropParams()): seq[ AssertReport[T]]

execProperty:

• pbt_types_execution: execProperty[A, B, C](ctx: var GlobalContext; name: string; arb1: Arbitrary[A]; arb2: Arbitrary[B]; arb3: Arbitrary[C]; pred: Predicate[(A, B, C)]; params: AssertParams = defAssertPropParams()): AssertReport[ (A, B, C)]
• pbt_types_execution: execProperty[A, B](ctx: var GlobalContext; name: string; arb1: Arbitrary[A]; arb2: Arbitrary[B]; pred: Predicate[(A, B)]; params: AssertParams = defAssertPropParams()): AssertReport[ (A, B)]
• pbt_types_execution: execProperty[A](ctx: var GlobalContext; name: string; arb: Arbitrary[A]; pred: Predicate[A]; params: AssertParams = defAssertPropParams()): seq[ AssertReport[A]]
• pbt_types_execution: execProperty[T](name: string; arb: Arbitrary[T]; check: Predicate[T]; params: AssertParams = defAssertPropParams()): RunExecution[T]

filter:

• pbt_types: filter[T](o: Arbitrary[T]; predicate: proc (t: T): bool): Arbitrary[T]
• pbt_types: filter[T](s: Shrinkable[T]; predicate: proc (t: T): bool): Shrinkable[T]

flatMap:

• pbt_types: flatMap[T, U](s: Arbitrary[T]; fmapper: proc (t: T): Arbitrary[U]): Arbitrary[U]

Frequency:

• pbt_types: Frequency

generate:

• pbt_types: generate[T](a: Arbitrary[T]; mrng: var Random): Shrinkable[T]
• pbt_types: generate[T](p: Property[T]; mrng: Random): Shrinkable[T]
• pbt_types: generate[T](p: var Property[T]; mrng: Random; runId: RunId): Shrinkable[T]

getFirst:

• arbitraries_core: getFirst[T](a: Arbitrary[T]; getN: int = 8; random: Random = newRandom()): seq[T]

getValue:

• pbt_types: getValue[T](a: Arbitrary[T]; mrng: var Random): T

GlobalContext:

• pbt_types_execution: GlobalContext

handleResult:

• pbt_types_execution: handleResult[T](runner: var Runner[T]; status: PTStatus)

hasFailure:

• pbt_types_execution: hasFailure(r: AssertReport): bool
• pbt_types_execution: hasFailure[T](ex: RunExecution[T]): bool

isSuccessful:

• pbt_types_execution: isSuccessful(r: AssertReport): bool

isUnspecified:

• pbt_types: isUnspecified(r: PossibleRunId): bool

items:

• pbt_types_execution: items[T](runner: var Runner[T]): RunnerYield[T]

map:

• pbt_types: map[T, U](o: Arbitrary[T]; mapper: proc (t: T): U): Arbitrary[U]
• pbt_types: map[T, U](s: Shrinkable[T]; mapper: proc (t: T): U): Shrinkable[U]

newProperty:

• pbt_types: newProperty[T](arb: Arbitrary[T]; p: Predicate): Property[T]

newRandom:

• pbt_types: newRandom(): Random
• pbt_types: newRandom(seed: uint32): Random

newRun:

• pbt_types: newRun(): RunId

newRunner:

• pbt_types_execution: newRunner[T](name: string; params: AssertParams; arb: Arbitrary[T]): Runner[T]

newRunnerYield:

• pbt_types_execution: newRunnerYield[T](shrinkable: Shrinkable[T]; done: bool = false): RunnerYield[T]

next:

• pbt_types_execution: next[T](runner: var Runner[T]): RunnerYield[T]

nextInt:

• pbt_types: nextInt(r: var Random): int
• pbt_types: nextInt(r: var Random; min, max: int): int

nextUint32:

• pbt_types: nextUint32(r: var Random): uint32
• pbt_types: nextUint32(r: var Random; min, max: uint32): uint32

noRunId:

• pbt_types: noRunId

PossibleRunId:

• pbt_types: PossibleRunId

Predicate:

• pbt_types: Predicate

Property:

• pbt_types: Property

propParams:

• pbt_types_execution: propParams(seed: uint32; path: seq[int]): AssertParams

ptFail:

• PTStatus.ptFail

ptPass:

• PTStatus.ptPass

ptPreCondFail:

• PTStatus.ptPreCondFail

PTStatus:

• pbt_types: PTStatus

Random:

• pbt_types: Random

recordFail:

• pbt_types_execution: recordFail[T](execution: var RunExecution[T]; value: T; id: int)

recordFailure:

• pbt_types_execution: recordFailure[T](r: var AssertReport[T]; example: T; ft: PTStatus)

recordPass:

• pbt_types_execution: recordPass[T](execution: var RunExecution[T]; value: T)

reportFailure:

• pbt_types_execution: reportFailure(ctx: var GlobalContext; msg: string)

reportSuccess:

• pbt_types_execution: reportSuccess(ctx: GlobalContext; msg: string)

run:

• pbt_types: run[T](p: Property[T]; v: T): PTStatus

RunExecution:

• pbt_types_execution: RunExecution

RunId:

• pbt_types: RunId

runIdToFrequency:

• pbt_types: runIdToFrequency(r: RunId): int

sample:

• pbt_types: sample[T](a: Arbitrary[T]; n: uint; mrng: var Random): seq[Shrinkable[T]]

seed:

• pbt_types: seed(r: Random): uint32

shrink:

• pbt_types: shrink[T](p: Property[T]; value: Shrinkable[T]): seq[Shrinkable[T]]

Shrinkable:

• pbt_types: Shrinkable

shrinkableOf:

• pbt_types: shrinkableOf[T](v: T): Shrinkable[T]
• pbt_types: shrinkableOf[T](v: var T): var Shrinkable[T]

ShrinkImpl:

• pbt_types: ShrinkImpl

spec:

• propertytest: spec(n: string = ""; body: untyped): untyped

startReport:

• pbt_types_execution: startReport[T](name: string; seed: uint32): AssertReport[T]

startRun:

• pbt_types: startRun(r: var PossibleRunId)
• pbt_types: startRun(r: var RunId): RunId
• pbt_types_execution: startRun[T](r: var AssertReport[T])

take:

• pbt_types: take[T](a: Arbitrary[T]; n: uint; mrng: var Random): Shrinkable[seq[T]]

toss:

• pbt_types: toss(mrng: var Random)