Macro proptest::prop_compose[][src]

macro_rules! prop_compose {
    ($(#[$meta:meta])*
     $([$($vis:tt)*])* fn $name:ident $params:tt
     ($($var:pat in $strategy:expr),+ $(,)*)
       -> $return_type:ty $body:block) => { ... };
    ($(#[$meta:meta])*
     $([$($vis:tt)*])* fn $name:ident $params:tt
     ($($var:pat in $strategy:expr),+ $(,)*)
     ($($var2:pat in $strategy2:expr),+ $(,)*)
       -> $return_type:ty $body:block) => { ... };
}

Convenience to define functions which produce new strategies.

The macro has two general forms. In the first, you define a function with two argument lists. The first argument list uses the usual syntax and becomes exactly the argument list of the defined function. The second argument list uses the in strategy syntax as with proptest!, and is used to generate the other inputs for the function. The second argument list has access to all arguments in the first. The return type indicates the type of value being generated; the final return type of the function is impl Strategy<Value = $type>.

#[macro_use] extern crate proptest;

#[derive(Clone, Debug)]
struct MyStruct {
  integer: u32,
  string: String,
}

prop_compose! {
  fn my_struct_strategy(max_integer: u32)
                       (integer in 0..max_integer, string in ".*")
                       -> MyStruct {
    MyStruct { integer, string }
  }
}

This form is simply sugar around making a tuple and then calling prop_map on it.

The second form is mostly the same, except that it takes three argument lists. The third argument list can see all values in both prior, which permits producing strategies based on other strategies.

#[macro_use] extern crate proptest;

prop_compose! {
  fn nearby_numbers()(centre in -1000..1000)
                   (a in centre-10..centre+10,
                    b in centre-10..centre+10)
                   -> (i32, i32) {
    (a, b)
  }
}

However, the body of the function does not have access to the second argument list. If the body needs access to those values, they must be passed through explicitly.

#[macro_use] extern crate proptest;
use proptest::prelude::*;

prop_compose! {
  fn vec_and_index
    (max_length: usize)
    (vec in prop::collection::vec(1..10, 1..max_length))
    (index in 0..vec.len(), vec in Just(vec))
    -> (Vec<i32>, usize)
  {
    (vec, index)
  }
}

The second form is sugar around making a strategy tuple, calling prop_flat_map(), then prop_map().

To give the function a visibility or unsafe modifier, put it in brackets before the fn token.

#[macro_use] extern crate proptest;
use proptest::prelude::*;

prop_compose! {
  [pub(crate) unsafe] fn pointer()(v in prop::num::usize::ANY)
                                -> *const () {
    v as *const ()
  }
}

Comparison with Hypothesis' @composite

prop_compose! makes it easy to do a lot of things you can do with Hypothesis' @composite, but not everything.