vendor/proptest-1.5.0/src/result.rs - toolchain/rustc - Git at Google

 //-
 // Copyright 2017 Jason Lingle
 //
 // 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.

 //! Strategies for combining delegate strategies into `std::Result`s.
 //!
 //! That is, the strategies here are for producing `Ok` _and_ `Err` cases. To
 //! simply adapt a strategy producing `T` into `Result<T, something>` which is
 //! always `Ok`, you can do something like `base_strategy.prop_map(Ok)` to
 //! simply wrap the generated values.
 //!
 //! Note that there are two nearly identical APIs for doing this, termed "maybe
 //! ok" and "maybe err". The difference between the two is in how they shrink;
 //! "maybe ok" treats `Ok` as the special case and shrinks to `Err`;
 //! conversely, "maybe err" treats `Err` as the special case and shrinks to
 //! `Ok`. Which to use largely depends on the code being tested; if the code
 //! typically handles errors by immediately bailing out and doing nothing else,
 //! "maybe ok" is likely more suitable, as shrinking will cause the code to
 //! take simpler paths. On the other hand, functions that need to make a
 //! complicated or fragile "back out" process on error are better tested with
 //! "maybe err" since the success case results in an easier to understand code
 //! path.

 #![cfg_attr(clippy, allow(expl_impl_clone_on_copy))]

 use core::fmt;
 use core::marker::PhantomData;

 use crate::std_facade::Arc;
 use crate::strategy::*;
 use crate::test_runner::*;

 // Re-export the type for easier usage.
 pub use crate::option::{prob, Probability};

 struct WrapOk<T, E>(PhantomData<T>, PhantomData<E>);
 impl<T, E> Clone for WrapOk<T, E> {
     fn clone(&self) -> Self {
         *self
     }
 }
 impl<T, E> Copy for WrapOk<T, E> {}
 impl<T, E> fmt::Debug for WrapOk<T, E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "WrapOk")
     }
 }
 impl<T: fmt::Debug, E: fmt::Debug> statics::MapFn<T> for WrapOk<T, E> {
     type Output = Result<T, E>;
     fn apply(&self, t: T) -> Result<T, E> {
         Ok(t)
     }
 }
 struct WrapErr<T, E>(PhantomData<T>, PhantomData<E>);
 impl<T, E> Clone for WrapErr<T, E> {
     fn clone(&self) -> Self {
         *self
     }
 }
 impl<T, E> Copy for WrapErr<T, E> {}
 impl<T, E> fmt::Debug for WrapErr<T, E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "WrapErr")
     }
 }
 impl<T: fmt::Debug, E: fmt::Debug> statics::MapFn<E> for WrapErr<T, E> {
     type Output = Result<T, E>;
     fn apply(&self, e: E) -> Result<T, E> {
         Err(e)
     }
 }

 type MapErr<T, E> =
     statics::Map<E, WrapErr<<T as Strategy>::Value, <E as Strategy>::Value>>;
 type MapOk<T, E> =
     statics::Map<T, WrapOk<<T as Strategy>::Value, <E as Strategy>::Value>>;

 opaque_strategy_wrapper! {
     /// Strategy which generates `Result`s using `Ok` and `Err` values from two
     /// delegate strategies.
     ///
     /// Shrinks to `Err`.
     #[derive(Clone)]
     pub struct MaybeOk[<T, E>][where T : Strategy, E : Strategy]
         (TupleUnion<(WA<MapErr<T, E>>, WA<MapOk<T, E>>)>)
         -> MaybeOkValueTree<T, E>;
     /// `ValueTree` type corresponding to `MaybeOk`.
     pub struct MaybeOkValueTree[<T, E>][where T : Strategy, E : Strategy]
         (TupleUnionValueTree<(
             LazyValueTree<statics::Map<E, WrapErr<T::Value, E::Value>>>,
             Option<LazyValueTree<statics::Map<T, WrapOk<T::Value, E::Value>>>>,
         )>)
         -> Result<T::Value, E::Value>;
 }

 opaque_strategy_wrapper! {
     /// Strategy which generates `Result`s using `Ok` and `Err` values from two
     /// delegate strategies.
     ///
     /// Shrinks to `Ok`.
     #[derive(Clone)]
     pub struct MaybeErr[<T, E>][where T : Strategy, E : Strategy]
         (TupleUnion<(WA<MapOk<T, E>>, WA<MapErr<T, E>>)>)
         -> MaybeErrValueTree<T, E>;
     /// `ValueTree` type corresponding to `MaybeErr`.
     pub struct MaybeErrValueTree[<T, E>][where T : Strategy, E : Strategy]
         (TupleUnionValueTree<(
             LazyValueTree<statics::Map<T, WrapOk<T::Value, E::Value>>>,
             Option<LazyValueTree<statics::Map<E, WrapErr<T::Value, E::Value>>>>,
         )>)
         -> Result<T::Value, E::Value>;
 }

 // These need to exist for the same reason as the one on `OptionStrategy`
 impl<T: Strategy + fmt::Debug, E: Strategy + fmt::Debug> fmt::Debug
     for MaybeOk<T, E>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "MaybeOk({:?})", self.0)
     }
 }
 impl<T: Strategy + fmt::Debug, E: Strategy + fmt::Debug> fmt::Debug
     for MaybeErr<T, E>
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "MaybeErr({:?})", self.0)
     }
 }

 impl<T: Strategy, E: Strategy> Clone for MaybeOkValueTree<T, E>
 where
     T::Tree: Clone,
     E::Tree: Clone,
 {
     fn clone(&self) -> Self {
         MaybeOkValueTree(self.0.clone())
     }
 }

 impl<T: Strategy, E: Strategy> fmt::Debug for MaybeOkValueTree<T, E>
 where
     T::Tree: fmt::Debug,
     E::Tree: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "MaybeOkValueTree({:?})", self.0)
     }
 }

 impl<T: Strategy, E: Strategy> Clone for MaybeErrValueTree<T, E>
 where
     T::Tree: Clone,
     E::Tree: Clone,
 {
     fn clone(&self) -> Self {
         MaybeErrValueTree(self.0.clone())
     }
 }

 impl<T: Strategy, E: Strategy> fmt::Debug for MaybeErrValueTree<T, E>
 where
     T::Tree: fmt::Debug,
     E::Tree: fmt::Debug,
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "MaybeErrValueTree({:?})", self.0)
     }
 }

 /// Create a strategy for `Result`s where `Ok` values are taken from `t` and
 /// `Err` values are taken from `e`.
 ///
 /// `Ok` and `Err` are chosen with equal probability.
 ///
 /// Generated values shrink to `Err`.
 pub fn maybe_ok<T: Strategy, E: Strategy>(t: T, e: E) -> MaybeOk<T, E> {
     maybe_ok_weighted(0.5, t, e)
 }

 /// Create a strategy for `Result`s where `Ok` values are taken from `t` and
 /// `Err` values are taken from `e`.
 ///
 /// `probability_of_ok` is the probability (between 0.0 and 1.0, exclusive)
 /// that `Ok` is initially chosen.
 ///
 /// Generated values shrink to `Err`.
 pub fn maybe_ok_weighted<T: Strategy, E: Strategy>(
     probability_of_ok: impl Into<Probability>,
     t: T,
     e: E,
 ) -> MaybeOk<T, E> {
     let prob = probability_of_ok.into().into();
     let (ok_weight, err_weight) = float_to_weight(prob);

     MaybeOk(TupleUnion::new((
         (
             err_weight,
             Arc::new(statics::Map::new(e, WrapErr(PhantomData, PhantomData))),
         ),
         (
             ok_weight,
             Arc::new(statics::Map::new(t, WrapOk(PhantomData, PhantomData))),
         ),
     )))
 }

 /// Create a strategy for `Result`s where `Ok` values are taken from `t` and
 /// `Err` values are taken from `e`.
 ///
 /// `Ok` and `Err` are chosen with equal probability.
 ///
 /// Generated values shrink to `Ok`.
 pub fn maybe_err<T: Strategy, E: Strategy>(t: T, e: E) -> MaybeErr<T, E> {
     maybe_err_weighted(0.5, t, e)
 }

 /// Create a strategy for `Result`s where `Ok` values are taken from `t` and
 /// `Err` values are taken from `e`.
 ///
 /// `probability_of_ok` is the probability (between 0.0 and 1.0, exclusive)
 /// that `Err` is initially chosen.
 ///
 /// Generated values shrink to `Ok`.
 pub fn maybe_err_weighted<T: Strategy, E: Strategy>(
     probability_of_err: impl Into<Probability>,
     t: T,
     e: E,
 ) -> MaybeErr<T, E> {
     let prob = probability_of_err.into().into();
     let (err_weight, ok_weight) = float_to_weight(prob);

     MaybeErr(TupleUnion::new((
         (
             ok_weight,
             Arc::new(statics::Map::new(t, WrapOk(PhantomData, PhantomData))),
         ),
         (
             err_weight,
             Arc::new(statics::Map::new(e, WrapErr(PhantomData, PhantomData))),
         ),
     )))
 }

 #[cfg(test)]
 mod test {
     use super::*;

     fn count_ok_of_1000(s: impl Strategy<Value = Result<(), ()>>) -> u32 {
         let mut runner = TestRunner::deterministic();
         let mut count = 0;
         for _ in 0..1000 {
             count += s.new_tree(&mut runner).unwrap().current().is_ok() as u32;
         }

         count
     }

     #[test]
     fn probability_defaults_to_0p5() {
         let count = count_ok_of_1000(maybe_err(Just(()), Just(())));
         assert!(count > 400 && count < 600);
         let count = count_ok_of_1000(maybe_ok(Just(()), Just(())));
         assert!(count > 400 && count < 600);
     }

     #[test]
     fn probability_handled_correctly() {
         let count =
             count_ok_of_1000(maybe_err_weighted(0.1, Just(()), Just(())));
         assert!(count > 800 && count < 950);

         let count =
             count_ok_of_1000(maybe_err_weighted(0.9, Just(()), Just(())));
         assert!(count > 50 && count < 150);

         let count =
             count_ok_of_1000(maybe_ok_weighted(0.9, Just(()), Just(())));
         assert!(count > 800 && count < 950);

         let count =
             count_ok_of_1000(maybe_ok_weighted(0.1, Just(()), Just(())));
         assert!(count > 50 && count < 150);
     }

     #[test]
     fn shrink_to_correct_case() {
         let mut runner = TestRunner::default();
         {
             let input = maybe_err(Just(()), Just(()));
             for _ in 0..64 {
                 let mut val = input.new_tree(&mut runner).unwrap();
                 if val.current().is_ok() {
                     assert!(!val.simplify());
                     assert!(val.current().is_ok());
                 } else {
                     assert!(val.simplify());
                     assert!(val.current().is_ok());
                 }
             }
         }
         {
             let input = maybe_ok(Just(()), Just(()));
             for _ in 0..64 {
                 let mut val = input.new_tree(&mut runner).unwrap();
                 if val.current().is_err() {
                     assert!(!val.simplify());
                     assert!(val.current().is_err());
                 } else {
                     assert!(val.simplify());
                     assert!(val.current().is_err());
                 }
             }
         }
     }

     #[test]
     fn test_sanity() {
         check_strategy_sanity(maybe_ok(0i32..100i32, 0i32..100i32), None);
         check_strategy_sanity(maybe_err(0i32..100i32, 0i32..100i32), None);
     }
 }
	//-
	// Copyright 2017 Jason Lingle
	//
	// 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.

	//! Strategies for combining delegate strategies into `std::Result`s.
	//!
	//! That is, the strategies here are for producing `Ok` _and_ `Err` cases. To
	//! simply adapt a strategy producing `T` into `Result<T, something>` which is
	//! always `Ok`, you can do something like `base_strategy.prop_map(Ok)` to
	//! simply wrap the generated values.
	//!
	//! Note that there are two nearly identical APIs for doing this, termed "maybe
	//! ok" and "maybe err". The difference between the two is in how they shrink;
	//! "maybe ok" treats `Ok` as the special case and shrinks to `Err`;
	//! conversely, "maybe err" treats `Err` as the special case and shrinks to
	//! `Ok`. Which to use largely depends on the code being tested; if the code
	//! typically handles errors by immediately bailing out and doing nothing else,
	//! "maybe ok" is likely more suitable, as shrinking will cause the code to
	//! take simpler paths. On the other hand, functions that need to make a
	//! complicated or fragile "back out" process on error are better tested with
	//! "maybe err" since the success case results in an easier to understand code
	//! path.

	#![cfg_attr(clippy, allow(expl_impl_clone_on_copy))]

	use core::fmt;
	use core::marker::PhantomData;

	use crate::std_facade::Arc;
	use crate::strategy::*;
	use crate::test_runner::*;

	// Re-export the type for easier usage.
	pub use crate::option::{prob, Probability};

	struct WrapOk<T, E>(PhantomData<T>, PhantomData<E>);
	impl<T, E> Clone for WrapOk<T, E> {
	fn clone(&self) -> Self {
	*self
	}
	}
	impl<T, E> Copy for WrapOk<T, E> {}
	impl<T, E> fmt::Debug for WrapOk<T, E> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "WrapOk")
	}
	}
	impl<T: fmt::Debug, E: fmt::Debug> statics::MapFn<T> for WrapOk<T, E> {
	type Output = Result<T, E>;
	fn apply(&self, t: T) -> Result<T, E> {
	Ok(t)
	}
	}
	struct WrapErr<T, E>(PhantomData<T>, PhantomData<E>);
	impl<T, E> Clone for WrapErr<T, E> {
	fn clone(&self) -> Self {
	*self
	}
	}
	impl<T, E> Copy for WrapErr<T, E> {}
	impl<T, E> fmt::Debug for WrapErr<T, E> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "WrapErr")
	}
	}
	impl<T: fmt::Debug, E: fmt::Debug> statics::MapFn<E> for WrapErr<T, E> {
	type Output = Result<T, E>;
	fn apply(&self, e: E) -> Result<T, E> {
	Err(e)
	}
	}

	type MapErr<T, E> =
	statics::Map<E, WrapErr<<T as Strategy>::Value, <E as Strategy>::Value>>;
	type MapOk<T, E> =
	statics::Map<T, WrapOk<<T as Strategy>::Value, <E as Strategy>::Value>>;

	opaque_strategy_wrapper! {
	/// Strategy which generates `Result`s using `Ok` and `Err` values from two
	/// delegate strategies.
	///
	/// Shrinks to `Err`.
	#[derive(Clone)]
	pub struct MaybeOk[<T, E>][where T : Strategy, E : Strategy]
	(TupleUnion<(WA<MapErr<T, E>>, WA<MapOk<T, E>>)>)
	-> MaybeOkValueTree<T, E>;
	/// `ValueTree` type corresponding to `MaybeOk`.
	pub struct MaybeOkValueTree[<T, E>][where T : Strategy, E : Strategy]
	(TupleUnionValueTree<(
	LazyValueTree<statics::Map<E, WrapErr<T::Value, E::Value>>>,
	Option<LazyValueTree<statics::Map<T, WrapOk<T::Value, E::Value>>>>,
	)>)
	-> Result<T::Value, E::Value>;
	}

	opaque_strategy_wrapper! {
	/// Strategy which generates `Result`s using `Ok` and `Err` values from two
	/// delegate strategies.
	///
	/// Shrinks to `Ok`.
	#[derive(Clone)]
	pub struct MaybeErr[<T, E>][where T : Strategy, E : Strategy]
	(TupleUnion<(WA<MapOk<T, E>>, WA<MapErr<T, E>>)>)
	-> MaybeErrValueTree<T, E>;
	/// `ValueTree` type corresponding to `MaybeErr`.
	pub struct MaybeErrValueTree[<T, E>][where T : Strategy, E : Strategy]
	(TupleUnionValueTree<(
	LazyValueTree<statics::Map<T, WrapOk<T::Value, E::Value>>>,
	Option<LazyValueTree<statics::Map<E, WrapErr<T::Value, E::Value>>>>,
	)>)
	-> Result<T::Value, E::Value>;
	}

	// These need to exist for the same reason as the one on `OptionStrategy`
	impl<T: Strategy + fmt::Debug, E: Strategy + fmt::Debug> fmt::Debug
	for MaybeOk<T, E>
	{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "MaybeOk({:?})", self.0)
	}
	}
	impl<T: Strategy + fmt::Debug, E: Strategy + fmt::Debug> fmt::Debug
	for MaybeErr<T, E>
	{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "MaybeErr({:?})", self.0)
	}
	}

	impl<T: Strategy, E: Strategy> Clone for MaybeOkValueTree<T, E>
	where
	T::Tree: Clone,
	E::Tree: Clone,
	{
	fn clone(&self) -> Self {
	MaybeOkValueTree(self.0.clone())
	}
	}

	impl<T: Strategy, E: Strategy> fmt::Debug for MaybeOkValueTree<T, E>
	where
	T::Tree: fmt::Debug,
	E::Tree: fmt::Debug,
	{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "MaybeOkValueTree({:?})", self.0)
	}
	}

	impl<T: Strategy, E: Strategy> Clone for MaybeErrValueTree<T, E>
	where
	T::Tree: Clone,
	E::Tree: Clone,
	{
	fn clone(&self) -> Self {
	MaybeErrValueTree(self.0.clone())
	}
	}

	impl<T: Strategy, E: Strategy> fmt::Debug for MaybeErrValueTree<T, E>
	where
	T::Tree: fmt::Debug,
	E::Tree: fmt::Debug,
	{
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
	write!(f, "MaybeErrValueTree({:?})", self.0)
	}
	}

	/// Create a strategy for `Result`s where `Ok` values are taken from `t` and
	/// `Err` values are taken from `e`.
	///
	/// `Ok` and `Err` are chosen with equal probability.
	///
	/// Generated values shrink to `Err`.
	pub fn maybe_ok<T: Strategy, E: Strategy>(t: T, e: E) -> MaybeOk<T, E> {
	maybe_ok_weighted(0.5, t, e)
	}

	/// Create a strategy for `Result`s where `Ok` values are taken from `t` and
	/// `Err` values are taken from `e`.
	///
	/// `probability_of_ok` is the probability (between 0.0 and 1.0, exclusive)
	/// that `Ok` is initially chosen.
	///
	/// Generated values shrink to `Err`.
	pub fn maybe_ok_weighted<T: Strategy, E: Strategy>(
	probability_of_ok: impl Into<Probability>,
	t: T,
	e: E,
	) -> MaybeOk<T, E> {
	let prob = probability_of_ok.into().into();
	let (ok_weight, err_weight) = float_to_weight(prob);

	MaybeOk(TupleUnion::new((
	(
	err_weight,
	Arc::new(statics::Map::new(e, WrapErr(PhantomData, PhantomData))),
	),
	(
	ok_weight,
	Arc::new(statics::Map::new(t, WrapOk(PhantomData, PhantomData))),
	),
	)))
	}

	/// Create a strategy for `Result`s where `Ok` values are taken from `t` and
	/// `Err` values are taken from `e`.
	///
	/// `Ok` and `Err` are chosen with equal probability.
	///
	/// Generated values shrink to `Ok`.
	pub fn maybe_err<T: Strategy, E: Strategy>(t: T, e: E) -> MaybeErr<T, E> {
	maybe_err_weighted(0.5, t, e)
	}

	/// Create a strategy for `Result`s where `Ok` values are taken from `t` and
	/// `Err` values are taken from `e`.
	///
	/// `probability_of_ok` is the probability (between 0.0 and 1.0, exclusive)
	/// that `Err` is initially chosen.
	///
	/// Generated values shrink to `Ok`.
	pub fn maybe_err_weighted<T: Strategy, E: Strategy>(
	probability_of_err: impl Into<Probability>,
	t: T,
	e: E,
	) -> MaybeErr<T, E> {
	let prob = probability_of_err.into().into();
	let (err_weight, ok_weight) = float_to_weight(prob);

	MaybeErr(TupleUnion::new((
	(
	ok_weight,
	Arc::new(statics::Map::new(t, WrapOk(PhantomData, PhantomData))),
	),
	(
	err_weight,
	Arc::new(statics::Map::new(e, WrapErr(PhantomData, PhantomData))),
	),
	)))
	}

	#[cfg(test)]
	mod test {
	use super::*;

	fn count_ok_of_1000(s: impl Strategy<Value = Result<(), ()>>) -> u32 {
	let mut runner = TestRunner::deterministic();
	let mut count = 0;
	for _ in 0..1000 {
	count += s.new_tree(&mut runner).unwrap().current().is_ok() as u32;
	}

	count
	}

	#[test]
	fn probability_defaults_to_0p5() {
	let count = count_ok_of_1000(maybe_err(Just(()), Just(())));
	assert!(count > 400 && count < 600);
	let count = count_ok_of_1000(maybe_ok(Just(()), Just(())));
	assert!(count > 400 && count < 600);
	}

	#[test]
	fn probability_handled_correctly() {
	let count =
	count_ok_of_1000(maybe_err_weighted(0.1, Just(()), Just(())));
	assert!(count > 800 && count < 950);

	let count =
	count_ok_of_1000(maybe_err_weighted(0.9, Just(()), Just(())));
	assert!(count > 50 && count < 150);

	let count =
	count_ok_of_1000(maybe_ok_weighted(0.9, Just(()), Just(())));
	assert!(count > 800 && count < 950);

	let count =
	count_ok_of_1000(maybe_ok_weighted(0.1, Just(()), Just(())));
	assert!(count > 50 && count < 150);
	}

	#[test]
	fn shrink_to_correct_case() {
	let mut runner = TestRunner::default();
	{
	let input = maybe_err(Just(()), Just(()));
	for _ in 0..64 {
	let mut val = input.new_tree(&mut runner).unwrap();
	if val.current().is_ok() {
	assert!(!val.simplify());
	assert!(val.current().is_ok());
	} else {
	assert!(val.simplify());
	assert!(val.current().is_ok());
	}
	}
	}
	{
	let input = maybe_ok(Just(()), Just(()));
	for _ in 0..64 {
	let mut val = input.new_tree(&mut runner).unwrap();
	if val.current().is_err() {
	assert!(!val.simplify());
	assert!(val.current().is_err());
	} else {
	assert!(val.simplify());
	assert!(val.current().is_err());
	}
	}
	}
	}

	#[test]
	fn test_sanity() {
	check_strategy_sanity(maybe_ok(0i32..100i32, 0i32..100i32), None);
	check_strategy_sanity(maybe_err(0i32..100i32, 0i32..100i32), None);
	}
	}