| //- |
| // Copyright 2017, 2019 The proptest developers |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use crate::std_facade::fmt; |
| |
| /// Easily define `proptest` tests. |
| /// |
| /// Within `proptest!`, define one or more functions without return type |
| /// normally, except instead of putting `: type` after each parameter, write |
| /// `in strategy`, where `strategy` is an expression evaluating to some |
| /// `Strategy`. |
| /// |
| /// Each function will be wrapped in a function which sets up a `TestRunner`, |
| /// and then invokes the function body with inputs generated according to the |
| /// strategies. |
| /// |
| /// ### Example |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn test_addition(a in 0..10, b in 0..10) { |
| /// prop_assert!(a + b <= 18); |
| /// } |
| /// |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn test_string_concat(a in ".*", b in ".*") { |
| /// let cat = format!("{}{}", a, b); |
| /// prop_assert_eq!(a.len() + b.len(), cat.len()); |
| /// } |
| /// } |
| /// # |
| /// # fn main() { test_addition(); test_string_concat(); } |
| /// ``` |
| /// |
| /// You can also use the normal argument syntax `pattern: type` as in: |
| /// |
| /// ```rust |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn addition_is_commutative(a: u8, b: u8) { |
| /// prop_assert_eq!(a as u16 + b as u16, b as u16 + a as u16); |
| /// } |
| /// |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn test_string_concat(a in ".*", b: String) { |
| /// let cat = format!("{}{}", a, b); |
| /// prop_assert_eq!(a.len() + b.len(), cat.len()); |
| /// } |
| /// } |
| /// # |
| /// # fn main() { addition_is_commutative(); test_string_concat(); } |
| /// ``` |
| /// |
| /// As you can see, you can mix `pattern: type` and `pattern in expr`. |
| /// Due to limitations in `macro_rules!`, `pattern: type` does not work in |
| /// all circumstances. In such a case, use `(pattern): type` instead. |
| /// |
| /// To override the default configuration, you can start the `proptest!` block |
| /// with `#![proptest_config(expr)]`, where `expr` is an expression that |
| /// evaluates to a `proptest::test_runner::Config` (or a reference to one). |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// #![proptest_config(ProptestConfig { |
| /// cases: 99, .. ProptestConfig::default() |
| /// })] |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn test_addition(a in 0..10, b in 0..10) { |
| /// prop_assert!(a + b <= 18); |
| /// } |
| /// } |
| /// # |
| /// # fn main() { test_addition(); } |
| /// ``` |
| /// |
| /// ## Closure-Style Invocation |
| /// |
| /// As of proptest 0.8.1, an alternative, "closure-style" invocation is |
| /// supported. In this form, `proptest!` is a function-like macro taking a |
| /// closure-esque argument. This makes it possible to run multiple tests that |
| /// require some expensive setup process. Note that the "fork" and "timeout" |
| /// features are _not_ supported in closure style. |
| /// |
| /// To use a custom configuration, pass the `Config` object as a first |
| /// argument. |
| /// |
| /// ### Example |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// #[derive(Debug)] |
| /// struct BigStruct { /* Lots of fields ... */ } |
| /// |
| /// fn very_expensive_function() -> BigStruct { |
| /// // Lots of code... |
| /// BigStruct { /* fields */ } |
| /// } |
| /// |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn my_test() { |
| /// // We create just one `BigStruct` |
| /// let big_struct = very_expensive_function(); |
| /// |
| /// // But now can run multiple tests without needing to build it every time. |
| /// // Note the extra parentheses around the arguments are currently |
| /// // required. |
| /// proptest!(|(x in 0u32..42u32, y in 1000u32..100000u32)| { |
| /// // Test stuff |
| /// }); |
| /// |
| /// // `move` closures are also supported |
| /// proptest!(move |(x in 0u32..42u32)| { |
| /// // Test other stuff |
| /// }); |
| /// |
| /// // You can pass a custom configuration as the first argument |
| /// proptest!(ProptestConfig::with_cases(1000), |(x: i32)| { |
| /// // Test more stuff |
| /// }); |
| /// } |
| /// # |
| /// # fn main() { my_test(); } |
| /// ``` |
| #[macro_export] |
| macro_rules! proptest { |
| (#![proptest_config($config:expr)] |
| $( |
| $(#[$meta:meta])* |
| fn $test_name:ident($($parm:pat in $strategy:expr),+ $(,)?) $body:block |
| )*) => { |
| $( |
| $(#[$meta])* |
| fn $test_name() { |
| let mut config = $config.clone(); |
| config.test_name = Some( |
| concat!(module_path!(), "::", stringify!($test_name))); |
| $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body); |
| } |
| )* |
| }; |
| (#![proptest_config($config:expr)] |
| $( |
| $(#[$meta:meta])* |
| fn $test_name:ident($($arg:tt)+) $body:block |
| )*) => { |
| $( |
| $(#[$meta])* |
| fn $test_name() { |
| let mut config = $config.clone(); |
| config.test_name = Some( |
| concat!(module_path!(), "::", stringify!($test_name))); |
| $crate::proptest_helper!(@_BODY2 config ($($arg)+) [] $body); |
| } |
| )* |
| }; |
| |
| ($( |
| $(#[$meta:meta])* |
| fn $test_name:ident($($parm:pat in $strategy:expr),+ $(,)?) $body:block |
| )*) => { $crate::proptest! { |
| #![proptest_config($crate::test_runner::Config::default())] |
| $($(#[$meta])* |
| fn $test_name($($parm in $strategy),+) $body)* |
| } }; |
| |
| ($( |
| $(#[$meta:meta])* |
| fn $test_name:ident($($arg:tt)+) $body:block |
| )*) => { $crate::proptest! { |
| #![proptest_config($crate::test_runner::Config::default())] |
| $($(#[$meta])* |
| fn $test_name($($arg)+) $body)* |
| } }; |
| |
| (|($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { |
| $crate::proptest!( |
| $crate::test_runner::Config::default(), |
| |($($parm in $strategy),+)| $body) |
| }; |
| |
| (move |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { |
| $crate::proptest!( |
| $crate::test_runner::Config::default(), |
| move |($($parm in $strategy),+)| $body) |
| }; |
| |
| (|($($arg:tt)+)| $body:expr) => { |
| $crate::proptest!( |
| $crate::test_runner::Config::default(), |
| |($($arg)+)| $body) |
| }; |
| |
| (move |($($arg:tt)+)| $body:expr) => { |
| $crate::proptest!( |
| $crate::test_runner::Config::default(), |
| move |($($arg)+)| $body) |
| }; |
| |
| ($config:expr, |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { { |
| let mut config = $config.__sugar_to_owned(); |
| $crate::sugar::force_no_fork(&mut config); |
| $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [] $body) |
| } }; |
| |
| ($config:expr, move |($($parm:pat in $strategy:expr),+ $(,)?)| $body:expr) => { { |
| let mut config = $config.__sugar_to_owned(); |
| $crate::sugar::force_no_fork(&mut config); |
| $crate::proptest_helper!(@_BODY config ($($parm in $strategy),+) [move] $body) |
| } }; |
| |
| ($config:expr, |($($arg:tt)+)| $body:expr) => { { |
| let mut config = $config.__sugar_to_owned(); |
| $crate::sugar::force_no_fork(&mut config); |
| $crate::proptest_helper!(@_BODY2 config ($($arg)+) [] $body); |
| } }; |
| |
| ($config:expr, move |($($arg:tt)+)| $body:expr) => { { |
| let mut config = $config.__sugar_to_owned(); |
| $crate::sugar::force_no_fork(&mut config); |
| $crate::proptest_helper!(@_BODY2 config ($($arg)+) [move] $body); |
| } }; |
| } |
| |
| /// Rejects the test input if assumptions are not met. |
| /// |
| /// Used directly within a function defined with `proptest!` or in any function |
| /// returning `Result<_, TestCaseError>`. |
| /// |
| /// This is invoked as `prop_assume!(condition, format, args...)`. `condition` |
| /// is evaluated; if it is false, `Err(TestCaseError::Reject)` is returned. The |
| /// message includes the point of invocation and the format message. `format` |
| /// and `args` may be omitted to simply use the condition itself as the |
| /// message. |
| #[macro_export] |
| macro_rules! prop_assume { |
| ($expr:expr) => { |
| $crate::prop_assume!($expr, "{}", stringify!($expr)) |
| }; |
| |
| ($expr:expr, $fmt:tt $(, $fmt_arg:expr),* $(,)?) => { |
| if !$expr { |
| return ::std::result::Result::Err( |
| $crate::test_runner::TestCaseError::reject( |
| format!(concat!("{}:{}:{}: ", $fmt), |
| file!(), line!(), column!() |
| $(, $fmt_arg)*))); |
| } |
| }; |
| } |
| |
| /// Produce a strategy which picks one of the listed choices. |
| /// |
| /// This is conceptually equivalent to calling `prop_union` on the first two |
| /// elements and then chaining `.or()` onto the rest after implicitly boxing |
| /// all of them. As with `Union`, values shrink across elements on the |
| /// assumption that earlier ones are "simpler", so they should be listed in |
| /// order of ascending complexity when possible. |
| /// |
| /// The macro invocation has two forms. The first is to simply list the |
| /// strategies separated by commas; this will cause value generation to pick |
| /// from the strategies uniformly. The other form is to provide a weight in the |
| /// form of a `u32` before each strategy, separated from the strategy with |
| /// `=>`. |
| /// |
| /// Note that the exact type returned by the macro varies depending on how many |
| /// inputs there are. In particular, if given exactly one option, it will |
| /// return it unmodified. It is not recommended to depend on the particular |
| /// type produced by this macro. |
| /// |
| /// ## Example |
| /// |
| /// ```rust,no_run |
| /// use proptest::prelude::*; |
| /// |
| /// #[derive(Clone, Copy, Debug)] |
| /// enum MyEnum { |
| /// Big(u64), |
| /// Medium(u32), |
| /// Little(i16), |
| /// } |
| /// |
| /// # #[allow(unused_variables)] |
| /// # fn main() { |
| /// let my_enum_strategy = prop_oneof![ |
| /// prop::num::i16::ANY.prop_map(MyEnum::Little), |
| /// prop::num::u32::ANY.prop_map(MyEnum::Medium), |
| /// prop::num::u64::ANY.prop_map(MyEnum::Big), |
| /// ]; |
| /// |
| /// let my_weighted_strategy = prop_oneof![ |
| /// 1 => prop::num::i16::ANY.prop_map(MyEnum::Little), |
| /// // Chose `Medium` twice as frequently as either `Little` or `Big`; i.e., |
| /// // around 50% of values will be `Medium`, and 25% for each of `Little` |
| /// // and `Big`. |
| /// 2 => prop::num::u32::ANY.prop_map(MyEnum::Medium), |
| /// 1 => prop::num::u64::ANY.prop_map(MyEnum::Big), |
| /// ]; |
| /// # } |
| /// ``` |
| #[macro_export] |
| macro_rules! prop_oneof { |
| ($($item:expr),+ $(,)?) => { |
| $crate::prop_oneof![ |
| $(1 => $item),* |
| ] |
| }; |
| |
| ($_weight0:expr => $item0:expr $(,)?) => { $item0 }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr, |
| $weight5:expr => $item5:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4), ($weight5, $item5))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr, |
| $weight5:expr => $item5:expr, |
| $weight6:expr => $item6:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4), ($weight5, $item5), |
| ($weight6, $item6))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr, |
| $weight5:expr => $item5:expr, |
| $weight6:expr => $item6:expr, |
| $weight7:expr => $item7:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4), ($weight5, $item5), |
| ($weight6, $item6), ($weight7, $item7))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr, |
| $weight5:expr => $item5:expr, |
| $weight6:expr => $item6:expr, |
| $weight7:expr => $item7:expr, |
| $weight8:expr => $item8:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4), ($weight5, $item5), |
| ($weight6, $item6), ($weight7, $item7), |
| ($weight8, $item8))) |
| }; |
| |
| ($weight0:expr => $item0:expr, |
| $weight1:expr => $item1:expr, |
| $weight2:expr => $item2:expr, |
| $weight3:expr => $item3:expr, |
| $weight4:expr => $item4:expr, |
| $weight5:expr => $item5:expr, |
| $weight6:expr => $item6:expr, |
| $weight7:expr => $item7:expr, |
| $weight8:expr => $item8:expr, |
| $weight9:expr => $item9:expr $(,)?) => { |
| $crate::strategy::TupleUnion::new( |
| (($weight0, $item0), ($weight1, $item1), |
| ($weight2, $item2), ($weight3, $item3), |
| ($weight4, $item4), ($weight5, $item5), |
| ($weight6, $item6), ($weight7, $item7), |
| ($weight8, $item8), ($weight9, $item9))) |
| }; |
| |
| ($($weight:expr => $item:expr),+ $(,)?) => { |
| $crate::strategy::Union::new_weighted(vec![ |
| $(($weight, $crate::strategy::Strategy::boxed($item))),* |
| ]) |
| }; |
| } |
| |
| /// 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>`. |
| /// |
| /// ```rust,no_run |
| /// # #![allow(dead_code)] |
| /// use proptest::prelude::*; |
| /// |
| /// #[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 } |
| /// } |
| /// } |
| /// # |
| /// # fn main() { } |
| /// ``` |
| /// |
| /// This form is simply sugar around making a tuple and then calling `prop_map` |
| /// on it. You can also use `arg: type` as in `proptest! { .. }`: |
| /// |
| /// ```rust,no_run |
| /// # #![allow(dead_code)] |
| /// # use proptest::prelude::*; |
| /// # |
| /// # #[derive(Clone, Debug)] |
| /// # struct MyStruct { |
| /// # integer: u32, |
| /// # string: String, |
| /// # } |
| /// |
| /// prop_compose! { |
| /// fn my_struct_strategy(max_integer: u32) |
| /// (integer in 0..max_integer, string: String) |
| /// -> MyStruct { |
| /// MyStruct { integer, string } |
| /// } |
| /// } |
| /// # |
| /// # fn main() { } |
| /// ``` |
| /// |
| /// 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. |
| /// |
| /// ```rust,no_run |
| /// # #![allow(dead_code)] |
| /// use proptest::prelude::*; |
| /// |
| /// 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) |
| /// } |
| /// } |
| /// # |
| /// # fn main() { } |
| /// ``` |
| /// |
| /// 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. |
| /// |
| /// ```rust,no_run |
| /// # #![allow(dead_code)] |
| /// 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) |
| /// } |
| /// } |
| /// # fn main() { } |
| /// ``` |
| /// |
| /// The second form is sugar around making a strategy tuple, calling |
| /// `prop_flat_map()`, then `prop_map()`. |
| /// |
| /// To give the function any modifier which isn't a visibility modifier, put it |
| /// in brackets before the `fn` token but after any visibility modifier. |
| /// |
| /// ```rust,no_run |
| /// # #![allow(dead_code)] |
| /// use proptest::prelude::*; |
| /// |
| /// prop_compose! { |
| /// pub(crate) [unsafe] fn pointer()(v in prop::num::usize::ANY) |
| /// -> *const () { |
| /// v as *const () |
| /// } |
| /// } |
| /// # fn main() { } |
| /// ``` |
| /// |
| /// ## Comparison with Hypothesis' `@composite` |
| /// |
| /// `prop_compose!` makes it easy to do a lot of things you can do with |
| /// [Hypothesis' `@composite`](https://hypothesis.readthedocs.io/en/latest/data.html#composite-strategies), |
| /// but not everything. |
| /// |
| /// - You can't filter via this macro. For filtering, you need to make the |
| /// strategy the "normal" way and use `prop_filter()`. |
| /// |
| /// - More than two layers of strategies or arbitrary logic between the two |
| /// layers. If you need either of these, you can achieve them by calling |
| /// `prop_flat_map()` by hand. |
| #[macro_export] |
| macro_rules! prop_compose { |
| ($(#[$meta:meta])* |
| $vis:vis |
| $([$($modi:tt)*])? fn $name:ident $params:tt |
| ($($var:pat in $strategy:expr),+ $(,)?) |
| -> $return_type:ty $body:block) => |
| { |
| #[must_use = "strategies do nothing unless used"] |
| $(#[$meta])* |
| $vis |
| $($($modi)*)? fn $name $params |
| -> impl $crate::strategy::Strategy<Value = $return_type> { |
| let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*)); |
| $crate::strategy::Strategy::prop_map(strat, |
| move |$crate::proptest_helper!(@_WRAPPAT ($($var),*))| $body) |
| } |
| }; |
| |
| ($(#[$meta:meta])* |
| $vis:vis |
| $([$($modi:tt)*])? fn $name:ident $params:tt |
| ($($var:pat in $strategy:expr),+ $(,)?) |
| ($($var2:pat in $strategy2:expr),+ $(,)?) |
| -> $return_type:ty $body:block) => |
| { |
| #[must_use = "strategies do nothing unless used"] |
| $(#[$meta])* |
| $vis |
| $($($modi)*)? fn $name $params |
| -> impl $crate::strategy::Strategy<Value = $return_type> { |
| let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*)); |
| let strat = $crate::strategy::Strategy::prop_flat_map( |
| strat, |
| move |$crate::proptest_helper!(@_WRAPPAT ($($var),*))| |
| $crate::proptest_helper!(@_WRAP ($($strategy2)*))); |
| $crate::strategy::Strategy::prop_map(strat, |
| move |$crate::proptest_helper!(@_WRAPPAT ($($var2),*))| $body) |
| } |
| }; |
| |
| ($(#[$meta:meta])* |
| $vis:vis |
| $([$($modi:tt)*])? fn $name:ident $params:tt |
| ($($arg:tt)+) |
| -> $return_type:ty $body:block) => |
| { |
| #[must_use = "strategies do nothing unless used"] |
| $(#[$meta])* |
| $vis |
| $($($modi)*)? fn $name $params |
| -> impl $crate::strategy::Strategy<Value = $return_type> { |
| let strat = $crate::proptest_helper!(@_EXT _STRAT ($($arg)+)); |
| $crate::strategy::Strategy::prop_map(strat, |
| move |$crate::proptest_helper!(@_EXT _PAT ($($arg)+))| $body) |
| } |
| }; |
| |
| ($(#[$meta:meta])* |
| $vis:vis |
| $([$($modi:tt)*])? fn $name:ident $params:tt |
| ($($arg:tt)+ $(,)?) |
| ($($arg2:tt)+ $(,)?) |
| -> $return_type:ty $body:block) => |
| { |
| #[must_use = "strategies do nothing unless used"] |
| $(#[$meta])* |
| $vis |
| $($($modi)*)? fn $name $params |
| -> impl $crate::strategy::Strategy<Value = $return_type> { |
| let strat = $crate::proptest_helper!(@_WRAP ($($strategy)*)); |
| let strat = $crate::strategy::Strategy::prop_flat_map( |
| strat, |
| move |$crate::proptest_helper!(@_EXT _PAT ($($arg)+))| |
| $crate::proptest_helper!(@_EXT _STRAT ($($arg2)*))); |
| $crate::strategy::Strategy::prop_map(strat, |
| move |$crate::proptest_helper!(@_EXT _PAT ($($arg2)*))| $body) |
| } |
| }; |
| } |
| |
| /// Similar to `assert!` from std, but returns a test failure instead of |
| /// panicking if the condition fails. |
| /// |
| /// This can be used in any function that returns a `Result<_, TestCaseError>`, |
| /// including the top-level function inside `proptest!`. |
| /// |
| /// Both panicking via `assert!` and returning a test case failure have the |
| /// same effect as far as proptest is concerned; however, the Rust runtime |
| /// implicitly prints every panic to stderr by default (including a backtrace |
| /// if enabled), which can make test failures unnecessarily noisy. By using |
| /// `prop_assert!` instead, the only output on a failing test case is the final |
| /// panic including the minimal test case. |
| /// |
| /// ## Example |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn triangle_inequality(a in 0.0f64..10.0, b in 0.0f64..10.0) { |
| /// // Called with just a condition will print the condition on failure |
| /// prop_assert!((a*a + b*b).sqrt() <= a + b); |
| /// // You can also provide a custom failure message |
| /// prop_assert!((a*a + b*b).sqrt() <= a + b, |
| /// "Triangle inequality didn't hold for ({}, {})", a, b); |
| /// // If calling another function that can return failure, don't forget |
| /// // the `?` to propagate the failure. |
| /// assert_from_other_function(a, b)?; |
| /// } |
| /// } |
| /// |
| /// // The macro can be used from another function provided it has a compatible |
| /// // return type. |
| /// fn assert_from_other_function(a: f64, b: f64) -> Result<(), TestCaseError> { |
| /// prop_assert!((a*a + b*b).sqrt() <= a + b); |
| /// Ok(()) |
| /// } |
| /// # |
| /// # fn main() { triangle_inequality(); } |
| /// ``` |
| #[macro_export] |
| macro_rules! prop_assert { |
| ($cond:expr) => { |
| $crate::prop_assert!($cond, concat!("assertion failed: ", stringify!($cond))) |
| }; |
| |
| ($cond:expr, $($fmt:tt)*) => { |
| if !$cond { |
| let message = format!($($fmt)*); |
| let message = format!("{} at {}:{}", message, file!(), line!()); |
| return ::std::result::Result::Err( |
| $crate::test_runner::TestCaseError::fail(message)); |
| } |
| }; |
| } |
| |
| /// Similar to `assert_eq!` from std, but returns a test failure instead of |
| /// panicking if the condition fails. |
| /// |
| /// See `prop_assert!` for a more in-depth discussion. |
| /// |
| /// ## Example |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn concat_string_length(ref a in ".*", ref b in ".*") { |
| /// let cat = format!("{}{}", a, b); |
| /// // Use with default message |
| /// prop_assert_eq!(a.len() + b.len(), cat.len()); |
| /// // Can also provide custom message (added after the normal |
| /// // assertion message) |
| /// prop_assert_eq!(a.len() + b.len(), cat.len(), |
| /// "a = {:?}, b = {:?}", a, b); |
| /// } |
| /// } |
| /// # |
| /// # fn main() { concat_string_length(); } |
| /// ``` |
| #[macro_export] |
| macro_rules! prop_assert_eq { |
| ($left:expr, $right:expr) => {{ |
| let left = $left; |
| let right = $right; |
| $crate::prop_assert!( |
| left == right, |
| "assertion failed: `(left == right)` (left: `{:?}`, right: `{:?}`)", |
| left, right); |
| }}; |
| |
| ($left:expr, $right:expr, $fmt:tt $($args:tt)*) => {{ |
| let left = $left; |
| let right = $right; |
| $crate::prop_assert!( |
| left == right, |
| concat!( |
| "assertion failed: `(left == right)` (left: `{:?}`, right: `{:?}`): ", $fmt), |
| left, right $($args)*); |
| }}; |
| } |
| |
| #[doc(hidden)] |
| #[macro_export] |
| macro_rules! proptest_helper { |
| (@_WRAP ($a:tt)) => { $a }; |
| (@_WRAP ($a0:tt $a1:tt)) => { ($a0, $a1) }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt)) => { ($a0, $a1, $a2) }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt)) => { ($a0, $a1, $a2, $a3) }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt $a4:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4) |
| }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt $a4:tt $a5:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5) |
| }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt $a4:tt $a5:tt $a6:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6) |
| }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt |
| $a4:tt $a5:tt $a6:tt $a7:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7) |
| }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt $a4:tt |
| $a5:tt $a6:tt $a7:tt $a8:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8) |
| }; |
| (@_WRAP ($a0:tt $a1:tt $a2:tt $a3:tt $a4:tt |
| $a5:tt $a6:tt $a7:tt $a8:tt $a9:tt)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9) |
| }; |
| (@_WRAP ($a:tt $($rest:tt)*)) => { |
| ($a, $crate::proptest_helper!(@_WRAP ($($rest)*))) |
| }; |
| (@_WRAPPAT ($item:pat)) => { $item }; |
| (@_WRAPPAT ($a0:pat, $a1:pat)) => { ($a0, $a1) }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat)) => { ($a0, $a1, $a2) }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat)) => { |
| ($a0, $a1, $a2, $a3) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, $a5:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, |
| $a4:pat, $a5:pat, $a6:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, |
| $a4:pat, $a5:pat, $a6:pat, $a7:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, |
| $a5:pat, $a6:pat, $a7:pat, $a8:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8) |
| }; |
| (@_WRAPPAT ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, |
| $a5:pat, $a6:pat, $a7:pat, $a8:pat, $a9:pat)) => { |
| ($a0, $a1, $a2, $a3, $a4, $a5, $a6, $a7, $a8, $a9) |
| }; |
| (@_WRAPPAT ($a:pat, $($rest:pat),*)) => { |
| ($a, $crate::proptest_helper!(@_WRAPPAT ($($rest),*))) |
| }; |
| (@_WRAPSTR ($item:pat)) => { stringify!($item) }; |
| (@_WRAPSTR ($a0:pat, $a1:pat)) => { (stringify!($a0), stringify!($a1)) }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), |
| stringify!($a3), stringify!($a4)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, $a5:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3), |
| stringify!($a4), stringify!($a5)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, |
| $a4:pat, $a5:pat, $a6:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3), |
| stringify!($a4), stringify!($a5), stringify!($a6)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, |
| $a4:pat, $a5:pat, $a6:pat, $a7:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3), |
| stringify!($a4), stringify!($a5), stringify!($a6), stringify!($a7)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, |
| $a5:pat, $a6:pat, $a7:pat, $a8:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3), |
| stringify!($a4), stringify!($a5), stringify!($a6), stringify!($a7), |
| stringify!($a8)) |
| }; |
| (@_WRAPSTR ($a0:pat, $a1:pat, $a2:pat, $a3:pat, $a4:pat, |
| $a5:pat, $a6:pat, $a7:pat, $a8:pat, $a9:pat)) => { |
| (stringify!($a0), stringify!($a1), stringify!($a2), stringify!($a3), |
| stringify!($a4), stringify!($a5), stringify!($a6), stringify!($a7), |
| stringify!($a8), stringify!($a9)) |
| }; |
| (@_WRAPSTR ($a:pat, $($rest:pat),*)) => { |
| (stringify!($a), $crate::proptest_helper!(@_WRAPSTR ($($rest),*))) |
| }; |
| // build a property testing block that when executed, executes the full property test. |
| (@_BODY $config:ident ($($parm:pat in $strategy:expr),+) [$($mod:tt)*] $body:expr) => {{ |
| $config.source_file = Some(file!()); |
| let mut runner = $crate::test_runner::TestRunner::new($config); |
| let names = $crate::proptest_helper!(@_WRAPSTR ($($parm),*)); |
| match runner.run( |
| &$crate::strategy::Strategy::prop_map( |
| $crate::proptest_helper!(@_WRAP ($($strategy)*)), |
| |values| $crate::sugar::NamedArguments(names, values)), |
| $($mod)* |$crate::sugar::NamedArguments( |
| _, $crate::proptest_helper!(@_WRAPPAT ($($parm),*)))| |
| { |
| $body; |
| Ok(()) |
| }) |
| { |
| Ok(_) => (), |
| Err(e) => panic!("{}\n{}", e, runner), |
| } |
| }}; |
| // build a property testing block that when executed, executes the full property test. |
| (@_BODY2 $config:ident ($($arg:tt)+) [$($mod:tt)*] $body:expr) => {{ |
| $config.source_file = Some(file!()); |
| let mut runner = $crate::test_runner::TestRunner::new($config); |
| let names = $crate::proptest_helper!(@_EXT _STR ($($arg)*)); |
| match runner.run( |
| &$crate::strategy::Strategy::prop_map( |
| $crate::proptest_helper!(@_EXT _STRAT ($($arg)*)), |
| |values| $crate::sugar::NamedArguments(names, values)), |
| $($mod)* |$crate::sugar::NamedArguments( |
| _, $crate::proptest_helper!(@_EXT _PAT ($($arg)*)))| |
| { |
| $body; |
| Ok(()) |
| }) |
| { |
| Ok(_) => (), |
| Err(e) => panic!("{}\n{}", e, runner), |
| } |
| }}; |
| |
| // The logic below helps support `pat: type` in the proptest! macro. |
| |
| // These matchers define the actual logic: |
| (@_STRAT [$s:ty] [$p:pat]) => { $crate::arbitrary::any::<$s>() }; |
| (@_PAT [$s:ty] [$p:pat]) => { $p }; |
| (@_STR [$s:ty] [$p:pat]) => { stringify!($p) }; |
| (@_STRAT in [$s:expr] [$p:pat]) => { $s }; |
| (@_PAT in [$s:expr] [$p:pat]) => { $p }; |
| (@_STR in [$s:expr] [$p:pat]) => { stringify!($p) }; |
| |
| // These matchers rewrite into the above extractors. |
| // We have to do this because `:` can't FOLLOW(pat). |
| // Note that this is not the full `pat` grammar... |
| // See https://docs.rs/syn/0.14.2/syn/enum.Pat.html for that. |
| (@_EXT $cmd:ident ($p:pat in $s:expr $(,)?)) => { |
| $crate::proptest_helper!(@$cmd in [$s] [$p]) |
| }; |
| (@_EXT $cmd:ident (($p:pat) : $s:ty $(,)?)) => { |
| // Users can wrap in parens as a last resort. |
| $crate::proptest_helper!(@$cmd [$s] [$p]) |
| }; |
| (@_EXT $cmd:ident (_ : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [_]) |
| }; |
| (@_EXT $cmd:ident (ref mut $p:ident : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [ref mut $p]) |
| }; |
| (@_EXT $cmd:ident (ref $p:ident : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [ref $p]) |
| }; |
| (@_EXT $cmd:ident (mut $p:ident : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [mut $p]) |
| }; |
| (@_EXT $cmd:ident ($p:ident : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [$p]) |
| }; |
| (@_EXT $cmd:ident ([$($p:tt)*] : $s:ty $(,)?)) => { |
| $crate::proptest_helper!(@$cmd [$s] [[$($p)*]]) |
| }; |
| |
| // Rewrite, Inductive case: |
| (@_EXT $cmd:ident ($p:pat in $s:expr, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd in [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident (($p:pat) : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident (_ : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [_]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident (ref mut $p:ident : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [ref mut $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident (ref $p:ident : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [ref $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident (mut $p:ident : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [mut $p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident ($p:ident : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [$p]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| (@_EXT $cmd:ident ([$($p:tt)*] : $s:ty, $($r:tt)*)) => { |
| ($crate::proptest_helper!(@$cmd [$s] [[$($p)*]]), $crate::proptest_helper!(@_EXT $cmd ($($r)*))) |
| }; |
| } |
| |
| #[doc(hidden)] |
| #[derive(Clone, Copy)] |
| pub struct NamedArguments<N, V>( |
| #[doc(hidden)] pub N, #[doc(hidden)] pub V); |
| |
| impl<V : fmt::Debug> fmt::Debug for NamedArguments<&'static str, V> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "{} = ", self.0)?; |
| self.1.fmt(f) |
| } |
| } |
| |
| macro_rules! named_arguments_tuple { |
| ($($ix:tt $argn:ident $argv:ident)*) => { |
| impl<'a, $($argn : Copy),*, $($argv),*> fmt::Debug |
| for NamedArguments<($($argn,)*),&'a ($($argv,)*)> |
| where $(NamedArguments<$argn, &'a $argv> : fmt::Debug),*, |
| $($argv : 'a),* |
| { |
| #[allow(unused_assignments)] |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| let mut first = true; |
| $( |
| if !first { |
| write!(f, ", ")?; |
| } |
| first = false; |
| fmt::Debug::fmt( |
| &NamedArguments((self.0).$ix, &(self.1).$ix), f)?; |
| )* |
| Ok(()) |
| } |
| } |
| |
| impl<$($argn : Copy),*, $($argv),*> fmt::Debug |
| for NamedArguments<($($argn,)*), ($($argv,)*)> |
| where $(for<'a> NamedArguments<$argn, &'a $argv> : fmt::Debug),* |
| { |
| #[allow(unused_assignments)] |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| let mut first = true; |
| $( |
| if !first { |
| write!(f, ", ")?; |
| } |
| first = false; |
| fmt::Debug::fmt( |
| &NamedArguments((self.0).$ix, &(self.1).$ix), f)?; |
| )* |
| Ok(()) |
| } |
| } |
| } |
| } |
| |
| named_arguments_tuple!(0 AN AV); |
| named_arguments_tuple!(0 AN AV 1 BN BV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV |
| 5 FN FV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV |
| 5 FN FV 6 GN GV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV |
| 5 FN FV 6 GN GV 7 HN HV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV |
| 5 FN FV 6 GN GV 7 HN HV 8 IN IV); |
| named_arguments_tuple!(0 AN AV 1 BN BV 2 CN CV 3 DN DV 4 EN EV |
| 5 FN FV 6 GN GV 7 HN HV 8 IN IV 9 JN JV); |
| |
| /// Similar to `assert_ne!` from std, but returns a test failure instead of |
| /// panicking if the condition fails. |
| /// |
| /// See `prop_assert!` for a more in-depth discussion. |
| /// |
| /// ## Example |
| /// |
| /// ``` |
| /// use proptest::prelude::*; |
| /// |
| /// proptest! { |
| /// # /* |
| /// #[test] |
| /// # */ |
| /// fn test_addition(a in 0i32..100i32, b in 1i32..100i32) { |
| /// // Use with default message |
| /// prop_assert_ne!(a, a + b); |
| /// // Can also provide custom message added after the common message |
| /// prop_assert_ne!(a, a + b, "a = {}, b = {}", a, b); |
| /// } |
| /// } |
| /// # |
| /// # fn main() { test_addition(); } |
| /// ``` |
| #[macro_export] |
| macro_rules! prop_assert_ne { |
| ($left:expr, $right:expr) => {{ |
| let left = $left; |
| let right = $right; |
| prop_assert!(left != right, "assertion failed: `(left != right)` \ |
| (left: `{:?}`, right: `{:?}`)", |
| left, right); |
| }}; |
| |
| ($left:expr, $right:expr, $fmt:tt $($args:tt)*) => {{ |
| let left = $left; |
| let right = $right; |
| prop_assert!(left != right, concat!( |
| "assertion failed: `(left != right)` \ |
| (left: `{:?}`, right: `{:?}`): ", $fmt), |
| left, right $($args)*); |
| }}; |
| } |
| |
| #[cfg(feature = "std")] |
| #[doc(hidden)] |
| pub fn force_no_fork(config: &mut crate::test_runner::Config) { |
| if config.fork() { |
| eprintln!("proptest: Forking/timeout not supported in closure-style \ |
| invocations; ignoring"); |
| |
| #[cfg(feature = "fork")] { |
| config.fork = false; |
| } |
| #[cfg(feature = "timeout")] { |
| config.timeout = 0; |
| } |
| assert!(!config.fork()); |
| } |
| } |
| |
| #[cfg(not(feature = "std"))] |
| pub fn force_no_fork(_: &mut crate::test_runner::Config) { } |
| |
| #[cfg(test)] |
| mod test { |
| use crate::strategy::Just; |
| |
| prop_compose! { |
| /// These are docs! |
| #[allow(dead_code)] |
| fn two_ints(relative: i32)(a in 0..relative, b in relative..) |
| -> (i32, i32) { |
| (a, b) |
| } |
| } |
| |
| prop_compose! { |
| /// These are docs! |
| #[allow(dead_code)] |
| pub fn two_ints_pub(relative: i32)(a in 0..relative, b in relative..) |
| -> (i32, i32) { |
| (a, b) |
| } |
| } |
| |
| prop_compose! { |
| /// These are docs! |
| #[allow(dead_code)] |
| pub [extern "C"] fn two_ints_pub_with_attrs |
| (relative: i32)(a in 0..relative, b in relative..) |
| -> (i32, i32) |
| { |
| (a, b) |
| } |
| } |
| |
| prop_compose! { |
| // The only modifier we can usefully put here is "unsafe", but we want |
| // to keep this crate unsafe-free, even nominally. "const" may |
| // eventually work, but is not allowed right now since the generated |
| // code contains local variables. `extern "C"` is accepted, even though |
| // the result is useless since the return type isn't C-compatible. |
| #[allow(dead_code)] |
| [extern "C"] fn with_modifier(relative: i32)(a in 0..relative) -> i32 { |
| a |
| } |
| } |
| |
| prop_compose! { |
| #[allow(dead_code)] |
| fn a_less_than_b()(b in 0..1000)(a in 0..b, b in Just(b)) |
| -> (i32, i32) { |
| (a, b) |
| } |
| } |
| |
| proptest! { |
| #[test] |
| fn test_something(a in 0u32..42u32, b in 1u32..10u32) { |
| prop_assume!(a != 41 || b != 9); |
| assert!(a + b < 50); |
| } |
| } |
| |
| prop_compose! { |
| #[allow(dead_code)] |
| fn single_closure_is_move(base: u64)(off in 0..10u64) -> u64 { |
| base + off |
| } |
| } |
| |
| prop_compose! { |
| #[allow(dead_code)] |
| fn double_closure_is_move |
| (base: u64) |
| (off1 in 0..10u64) |
| (off2 in off1..off1+10) |
| -> u64 |
| { |
| base + off2 |
| } |
| } |
| |
| #[allow(unused_variables)] |
| mod test_arg_counts { |
| use crate::strategy::Just; |
| |
| proptest! { |
| #[test] |
| fn test_1_arg(a in Just(0)) { } |
| #[test] |
| fn test_2_arg(a in Just(0), b in Just(0)) { } |
| #[test] |
| fn test_3_arg(a in Just(0), b in Just(0), c in Just(0)) { } |
| #[test] |
| fn test_4_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0)) { } |
| #[test] |
| fn test_5_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0)) { } |
| #[test] |
| fn test_6_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0)) { } |
| #[test] |
| fn test_7_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0)) { } |
| #[test] |
| fn test_8_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0), h in Just(0)) { } |
| #[test] |
| fn test_9_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0), h in Just(0), i in Just(0)) { } |
| #[test] |
| fn test_a_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0), h in Just(0), i in Just(0), |
| j in Just(0)) { } |
| #[test] |
| fn test_b_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0), h in Just(0), i in Just(0), |
| j in Just(0), k in Just(0)) { } |
| #[test] |
| fn test_c_arg(a in Just(0), b in Just(0), c in Just(0), |
| d in Just(0), e in Just(0), f in Just(0), |
| g in Just(0), h in Just(0), i in Just(0), |
| j in Just(0), k in Just(0), l in Just(0)) { } |
| } |
| } |
| |
| #[test] |
| fn named_arguments_is_debug_for_needed_cases() { |
| use super::NamedArguments; |
| |
| println!("{:?}", NamedArguments("foo", &"bar")); |
| println!("{:?}", NamedArguments(("foo",), &(1,))); |
| println!("{:?}", NamedArguments(("foo","bar"), &(1,2))); |
| println!("{:?}", NamedArguments(("a","b","c"), &(1,2,3))); |
| println!("{:?}", NamedArguments(("a","b","c","d"), &(1,2,3,4))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e"), |
| &(1,2,3,4,5))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e","f"), |
| &(1,2,3,4,5,6))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e","f","g"), |
| &(1,2,3,4,5,6,7))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e","f","g","h"), |
| &(1,2,3,4,5,6,7,8))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e","f","g","h","i"), |
| &(1,2,3,4,5,6,7,8,9))); |
| println!("{:?}", NamedArguments(("a","b","c","d","e","f","g","h","i","j"), |
| &(1,2,3,4,5,6,7,8,9,10))); |
| println!("{:?}", NamedArguments((("a","b"),"c","d"), &((1,2),3,4))); |
| } |
| |
| #[test] |
| fn oneof_all_counts() { |
| use crate::strategy::{Strategy, TupleUnion, Union, Just as J}; |
| |
| fn expect_count(n: usize, s: impl Strategy<Value = i32>) { |
| use std::collections::HashSet; |
| use crate::strategy::*; |
| use crate::test_runner::*; |
| |
| let mut runner = TestRunner::default(); |
| let mut seen = HashSet::new(); |
| for _ in 0..1024 { |
| seen.insert(s.new_tree(&mut runner).unwrap().current()); |
| } |
| |
| assert_eq!(n, seen.len()); |
| } |
| |
| fn assert_static<T>(v: TupleUnion<T>) -> TupleUnion<T> { v } |
| fn assert_dynamic<T: Strategy>(v: Union<T>) -> Union<T> { v } |
| |
| expect_count(1, prop_oneof![J(0i32)]); |
| expect_count(2, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| ])); |
| expect_count(3, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| ])); |
| expect_count(4, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| ])); |
| expect_count(5, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| ])); |
| expect_count(6, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| ])); |
| expect_count(7, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| J(6i32), |
| ])); |
| expect_count(8, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| J(6i32), |
| J(7i32), |
| ])); |
| expect_count(9, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| J(6i32), |
| J(7i32), |
| J(8i32), |
| ])); |
| expect_count(10, assert_static(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| J(6i32), |
| J(7i32), |
| J(8i32), |
| J(9i32), |
| ])); |
| expect_count(11, assert_dynamic(prop_oneof![ |
| J(0i32), |
| J(1i32), |
| J(2i32), |
| J(3i32), |
| J(4i32), |
| J(5i32), |
| J(6i32), |
| J(7i32), |
| J(8i32), |
| J(9i32), |
| J(10i32), |
| ])); |
| } |
| } |
| |
| #[cfg(all(test, feature = "timeout"))] |
| mod test_timeout { |
| proptest! { |
| #![proptest_config(crate::test_runner::Config { |
| fork: true, |
| .. crate::test_runner::Config::default() |
| })] |
| |
| // Ensure that the macro sets the test name properly. If it doesn't, |
| // this test will fail to run correctly. |
| #[test] |
| fn test_name_set_correctly_for_fork(_ in 0u32..1u32) { } |
| } |
| } |
| |
| #[cfg(test)] |
| mod another_test { |
| use crate::sugar; |
| |
| // Ensure that we can access the `[pub]` composed function above. |
| #[allow(dead_code)] |
| fn can_access_pub_compose() { |
| let _ = sugar::test::two_ints_pub(42); |
| let _ = sugar::test::two_ints_pub_with_attrs(42); |
| } |
| } |
| |
| #[cfg(test)] |
| mod ownership_tests { |
| #[cfg(feature = "std")] |
| proptest! { |
| #[test] |
| fn accept_ref_arg(ref s in "[0-9]") { |
| use crate::std_facade::String; |
| fn assert_string(_s: &String) {} |
| assert_string(s); |
| } |
| |
| #[test] |
| fn accept_move_arg(s in "[0-9]") { |
| use crate::std_facade::String; |
| fn assert_string(_s: String) {} |
| assert_string(s); |
| } |
| } |
| |
| #[derive(Debug)] |
| struct NotClone(); |
| const MK: fn() -> NotClone = NotClone; |
| |
| proptest! { |
| #[test] |
| fn accept_noclone_arg(nc in MK) { |
| let _nc2: NotClone = nc; |
| } |
| |
| #[test] |
| fn accept_noclone_ref_arg(ref nc in MK) { |
| let _nc2: &NotClone = nc; |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod closure_tests { |
| #[test] |
| fn test_simple() { |
| let x = 420; |
| |
| proptest!(|(y: i32)| { |
| assert!(x != y); |
| }); |
| |
| proptest!(|(y in 0..100)| { |
| println!("{}", y); |
| assert!(x != y); |
| }); |
| |
| proptest!(|(y: i32,)| { |
| assert!(x != y); |
| }); |
| |
| proptest!(|(y in 0..100,)| { |
| println!("{}", y); |
| assert!(x != y); |
| }); |
| } |
| |
| #[test] |
| fn test_move() { |
| let foo = Foo; |
| |
| proptest!(move |(x in 1..100, y in 0..100)| { |
| assert!(x + y > 0, "foo: {:?}", foo); |
| }); |
| |
| let foo = Foo; |
| proptest!(move |(x: (), y: ())| { |
| assert!(x == y, "foo: {:?}", foo); |
| }); |
| |
| #[derive(Debug)] |
| struct Foo; |
| } |
| |
| #[test] |
| #[should_panic] |
| #[allow(unreachable_code)] |
| fn fails_if_closure_panics() { |
| proptest!(|(_ in 0..1)| { |
| panic!() |
| }); |
| } |
| |
| #[test] |
| fn accepts_unblocked_syntax() { |
| proptest!(|(x in 0u32..10, y in 10u32..20)| assert!(x < y)); |
| proptest!(|(x in 0u32..10, y in 10u32..20,)| assert!(x < y)); |
| } |
| |
| #[test] |
| fn accepts_custom_config() { |
| let conf = crate::test_runner::Config::default(); |
| |
| proptest!(conf, |(x in 0u32..10, y in 10u32..20)| assert!(x < y)); |
| proptest!(&conf, |(x in 0u32..10, y in 10u32..20)| assert!(x < y)); |
| proptest!(conf, move |(x in 0u32..10, y in 10u32..20)| assert!(x < y)); |
| proptest!(conf, |(_x: u32, _y: u32)| { }); |
| proptest!(conf, move |(_x: u32, _y: u32)| { }); |
| |
| // Same as above, but with extra trailing comma |
| proptest!(conf, |(x in 0u32..10, y in 10u32..20,)| assert!(x < y)); |
| proptest!(&conf, |(x in 0u32..10, y in 10u32..20,)| assert!(x < y)); |
| proptest!(conf, move |(x in 0u32..10, y in 10u32..20,)| assert!(x < y)); |
| proptest!(conf, |(_x: u32, _y: u32,)| { }); |
| proptest!(conf, move |(_x: u32, _y: u32,)| { }); |
| } |
| } |
| |
| #[cfg(test)] |
| mod any_tests { |
| proptest! { |
| #[test] |
| fn test_something |
| ( |
| a: bool, |
| b in 25u8.., |
| c in 25u8.., |
| _d: (), |
| mut _e: (), |
| ref _f: (), |
| ref mut _g: (), |
| [_, _]: [(); 2], |
| ) { |
| if a {} // Assert bool. |
| assert!(b as usize + c as usize >= 50); |
| } |
| } |
| |
| // Test that the macro accepts some of the inputs we expect it to: |
| #[test] |
| fn proptest_ext_test() { |
| struct Y(pub u8); |
| |
| let _ = proptest_helper!(@_EXT _STRAT( _ : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( x : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( ref x : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( mut x : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( ref mut x : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( [_, _] : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( (&mut &Y(ref x)) : u8 )); |
| let _ = proptest_helper!(@_EXT _STRAT( x in 1..2 )); |
| |
| let proptest_helper!(@_EXT _PAT( _ : u8 )) = 1; |
| let proptest_helper!(@_EXT _PAT( _x : u8 )) = 1; |
| let proptest_helper!(@_EXT _PAT( mut _x : u8 )) = 1; |
| let proptest_helper!(@_EXT _PAT( ref _x : u8 )) = 1; |
| let proptest_helper!(@_EXT _PAT( ref mut _x : u8 )) = 1; |
| let proptest_helper!(@_EXT _PAT( [_, _] : u8 )) = [1, 2]; |
| let proptest_helper!(@_EXT _PAT( (&mut &Y(ref _x)) : u8 )) = &mut &Y(1); |
| let proptest_helper!(@_EXT _PAT( _x in 1..2 )) = 1; |
| } |
| } |
