Logo Hegel for F#

Hegel.FSharp Namespace

Type/Module Description

ArrayGen<'T>

Draws arrays from an element generator, printed as [|a; b|].

ArrayGenerator<'T>

Backend

BigIntegerGenerator

BinaryGenerator

CaseOutcome

ConcurrentPool<'T>

Database

DateGenerator

DateTimeGenerator

Deferred<'T>

Dialect

DidNotReproduceException

Document

DomainGenerator

DoubleGenerator

Example

Failure

FlakyTestException

FloatGenerator

Gen

The generator catalogue for F#. The scalar generators are the C# ones, whose builder methods (Gen.int.Min(0).Max(10)) narrow them; the collection, option, tuple, record and union generators are F#'s own, drawing F# values and printing them as F#. Generators compose with , and , or in a gen { } block.

GenBuilder (Module)

GenBuilder (Type)

The gen { } block: let! draws from a generator and return gives the value, which is printed as the block's draw.

Generator<'T>

Generators

HealthCheck

HealthCheckFailure

Hegel

 Entry points: Hegel.test runs a property and throws its failure, as a test function wants;
 Hegel.run returns the  instead. Both print the failing test case as
 F# (let xs_1 = [0; 0]) and identify the test to the database from the calling function.
 
 [<Fact>]
 let ``addition commutes`` () =
     Hegel.test (fun tc ->
         let a = tc.Draw Gen.int
         let b = tc.Draw Gen.int
         Assert.Equal(a + b, b + a))
 

HegelException

HegelInfrastructureAttribute

HegelRunException

HegelUsageException

IntegerGenerator

InvalidExampleException

InvariantAttribute

IpAddressGenerator

Label

LarkGenerator

ListGen<'T>

Draws F# lists from an element generator, printed as [a; b].

ListGenerator<'T>

LongGenerator

MapGen<'Key, 'Value>

Draws F# maps from a key and a value generator, printed as Map [(k, v)].

MapGenerator<'Key, 'Value>

MultipleFailuresException

NondeterminismStrictness

OptionGen<'T>

Draws options: None or Some(value) from the inner generator, with equal probability.

Phase

Pool<'T>

PrintableGenerator<'T>

Printer

Property

RecordGen<'T>

Draws F# records by drawing each field from the generator holds for it, printed as { A = a; B = b }. Gen.record starts from the generators derived from the field types, which .With replaces one at a time.

RecordGenerator<'T>

RecursiveGenerator<'T>

RegexGenerator

Reporter

Repr

Prints values as the F# that builds them: what the draws of a failing test are shown as under Hegel.test, and what a generator that prints its values itself should produce.

RuleAttribute

RunErrorKind

RunReport

RunStatistics

RunStatus

SampleGenerator<'T>

SetGen<'T>

Draws F# sets from an element generator, printed as set [a; b].

SetGenerator<'T>

Settings

Stateful

StatefulOptions

SubsequenceGenerator<'T>

TestCase

TestLocation

TextGenerator

TimeGenerator

TupleGen<'T>

Draws a tuple, one element from each generator, printed as (a, b).

UnionGen<'T>

Draws F# union values: a case chosen uniformly, its fields drawn from their generators, printed as Case or Case(a, b).

UnsatisfiableException

UuidGenerator

ValueOptionGen<'T>

Draws value options: ValueNone or ValueSome(value), with equal probability.

Verbosity

Type something to start searching.