# Crate diceprop[−][src]

Expand description

A collection of mathematical properties for random testing.

It’s based on dicetest.

# Status of this crate

The author does not consider this crate as stable yet. Changes will be documented in the changelog.

# Examples

## Associative binary operation

``````use diceprop::{props, Fun2, Set};
use dicetest::prelude::*;

#[test]
Dicetest::repeatedly().run(|mut fate| {
let set = Set::new("f32 ∩ [-100,100]", dice::f32(-100.0..=100.0));
let vars = fate.roll(set.vars(["x", "y", "z"]));
let add = Fun2::infix("+", |x, y| x + y);
})
}``````

The test fails with the following output:

``````The test failed after 12 passes.

- seed: 14859458141222391139
- start limit: 0
- end limit: 100
- passes: 200

- run code: "2pYRCj9fj8sV52fB5iyFhxCISGY3nKlMzlzIKq0NKLwGAAAAAAAAAA=="
- limit: 6
- hints:
- Is `+` associative?
- x, y, z of f32 ∩ [-100,100]
- x = 96.621735
- y = -90.97134
- z = -8.10239
- (x + y) = 5.6503983
- ((x + y) + z) = -2.451992
- (y + z) = -99.07373
- (x + (y + z)) = -2.4519958
- (((x + y) + z) == (x + (y + z))) = false
- error: assertion failed: (((x + y) + z) == (x + (y + z)))``````

## Left inverse function

``````use diceprop::{props, Fun1, Set};
use dicetest::prelude::*;

#[test]
fn sqrt_is_left_inverse_of_sq_for_non_negative_f32() {
Dicetest::repeatedly().run(|mut fate| {
let set = Set::new("f32 ∩ [0,+∞]", dice::f32(0.0..));
let vars = fate.roll(set.vars(["x"]));
let sq = Fun1::postfix("²", |x| x * x);
let sqrt = Fun1::new("√", |x: f32| x.sqrt());
props::fun::left_inverse(vars, sq, sqrt);
})
}``````

The test fails with the following output:

``````The test failed after 0 passes.

- seed: 7632522237817347676
- start limit: 0
- end limit: 100
- passes: 200

- run code: "F2/nnlbX6qyCOm5MU7P8BSXdnJ4XNXJdihgwhtWxlzMAAAAAAAAAAA=="
- limit: 0
- hints:
- Is `√` left inverse of `²`?
- x of f32 ∩ [0,+∞]
- x = 305770290000000000000000000000000000000.0
- (x)² = inf
- √((x)²) = inf
- (√((x)²) == x) = false
- error: assertion failed: (√((x)²) == x)``````

## Partial order

``````use diceprop::{props, Fun2, Set};
use dicetest::prelude::*;

#[test]
fn gt_is_partial_order_for_any_f32() {
Dicetest::repeatedly().run(|mut fate| {
let set = Set::new("f32", dice::any_f32());
let vars = fate.roll(set.vars(["x", "y", "z"]));
let gt = Fun2::infix("≤", |x, y| x <= y);
props::binrel::partial_order(vars, gt);
})
}``````

The test fails with the following output:

``````The test failed after 3 passes.

- seed: 18374838706510982620
- start limit: 0
- end limit: 100
- passes: 200

- run code: "h6jQMNr6fi/j9OZOXmklXYAUATM96EpE6+DENMhSZHkBAAAAAAAAAA=="
- limit: 1
- hints:
- Is `≤` a partial order?
- Is `≤` reflexive?
- x of f32
- x = NaN
- (x ≤ x) = false
- error: assertion failed: (x ≤ x)``````

## Modules

A collection of operations on `Eval` that are useful for writing properties.

A collection of properties that can be verified with randomly generated test data.

## Structs

Represents an element of type `S`.

Represents a evaluated expression of type `S`.

Represents a function of arity 1.

A human-readable label that describes a `Fun1` applied to an argument.

Represents a function of arity 2.

A human-readable label that describes a `Fun2` applied to arguments.

Represents a function of arity 3.

A human-readable label that describes a `Fun3` applied to arguments.

A mathematical set that can be used to randomly choose `Vars`.

Represents elements that were chosen from a set and that can be used as variables in properties.