vendor/proptest-1.0.0/src/array.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.

 //! Support for strategies producing fixed-length arrays.
 //!
 //! An array of strategies (but only length 1 to 32 for now) is itself a
 //! strategy which generates arrays of that size drawing elements from the
 //! corresponding input strategies.
 //!
 //! See also [`UniformArrayStrategy`](struct.UniformArrayStrategy.html) for
 //! easily making a strategy for an array drawn from one strategy.
 //!
 //! General implementations are available for sizes 1 through 32.

 use core::marker::PhantomData;

 use crate::strategy::*;
 use crate::test_runner::*;

 /// A `Strategy` which generates fixed-size arrays containing values drawn from
 /// an inner strategy.
 ///
 /// `T` must be an array type of length 1 to 32 whose values are produced by
 /// strategy `S`. Instances of this type are normally created by the various
 /// `uniformXX` functions in this module.
 ///
 /// This is mainly useful when the inner strategy is not `Copy`, precluding
 /// expressing the strategy as `[myStrategy; 32]`, for example.
 ///
 /// ## Example
 ///
 /// ```
 /// use proptest::prelude::*;
 ///
 /// proptest! {
 ///   #[test]
 ///   fn test_something(a in prop::array::uniform32(1u32..)) {
 ///     let unexpected = [0u32;32];
 ///     // `a` is also a [u32;32], so we can compare them directly
 ///     assert_ne!(unexpected, a);
 ///   }
 /// }
 /// # fn main() { }
 /// ```
 #[must_use = "strategies do nothing unless used"]
 #[derive(Clone, Copy, Debug)]
 pub struct UniformArrayStrategy<S, T> {
     strategy: S,
     _marker: PhantomData<T>,
 }

 impl<S, T> UniformArrayStrategy<S, T> {
     /// Directly create a `UniformArrayStrategy`.
     ///
     /// This is only intended for advanced use, since the only way to specify
     /// the array size is with the turbofish operator and explicitly naming the
     /// type of the values in the array and the strategy itself.
     ///
     /// Prefer the `uniformXX` functions at module-level unless something
     /// precludes their use.
     pub fn new(strategy: S) -> Self {
         UniformArrayStrategy {
             strategy,
             _marker: PhantomData,
         }
     }
 }

 /// A `ValueTree` operating over a fixed-size array.
 #[derive(Clone, Copy, Debug)]
 pub struct ArrayValueTree<T> {
     tree: T,
     shrinker: usize,
     last_shrinker: Option<usize>,
 }

 macro_rules! small_array {
     ($n:tt $uni:ident : $($ix:expr),*) => {
         /// Create a strategy to generate fixed-length arrays.
         ///
         /// All values within the new strategy are generated using the given
         /// strategy. The length of the array corresponds to the suffix of the
         /// name of this function.
         ///
         /// See [`UniformArrayStrategy`](struct.UniformArrayStrategy.html) for
         /// example usage.
         pub fn $uni<S : Strategy>
             (strategy: S) -> UniformArrayStrategy<S, [S::Value; $n]>
         {
             UniformArrayStrategy {
                 strategy,
                 _marker: PhantomData
             }
         }

         impl<S : Strategy> Strategy for [S; $n] {
             type Tree = ArrayValueTree<[S::Tree; $n]>;
             type Value = [S::Value; $n];

             fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
                 Ok(ArrayValueTree {
                     tree: [$(self[$ix].new_tree(runner)?,)*],
                     shrinker: 0,
                     last_shrinker: None,
                 })
             }
         }

         impl<S : Strategy> Strategy
         for UniformArrayStrategy<S, [S::Value; $n]> {
             type Tree = ArrayValueTree<[S::Tree; $n]>;
             type Value = [S::Value; $n];

             fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
                 Ok(ArrayValueTree {
                     tree: [$({
                         let _ = $ix;
                         self.strategy.new_tree(runner)?
                     },)*],
                     shrinker: 0,
                     last_shrinker: None,
                 })
             }
         }

         impl<T : ValueTree> ValueTree for ArrayValueTree<[T;$n]> {
             type Value = [T::Value;$n];

             fn current(&self) -> [T::Value;$n] {
                 [$(self.tree[$ix].current(),)*]
             }

             fn simplify(&mut self) -> bool {
                 while self.shrinker < $n {
                     if self.tree[self.shrinker].simplify() {
                         self.last_shrinker = Some(self.shrinker);
                         return true;
                     } else {
                         self.shrinker += 1;
                     }
                 }

                 false
             }

             fn complicate(&mut self) -> bool {
                 if let Some(shrinker) = self.last_shrinker {
                     self.shrinker = shrinker;
                     if self.tree[shrinker].complicate() {
                         true
                     } else {
                         self.last_shrinker = None;
                         false
                     }
                 } else {
                     false
                 }
             }
         }
     }
 }

 small_array!(1 uniform1:
              0);
 small_array!(2 uniform2:
              0, 1);
 small_array!(3 uniform3:
              0, 1, 2);
 small_array!(4 uniform4:
              0, 1, 2, 3);
 small_array!(5 uniform5:
              0, 1, 2, 3, 4);
 small_array!(6 uniform6:
              0, 1, 2, 3, 4, 5);
 small_array!(7 uniform7:
              0, 1, 2, 3, 4, 5, 6);
 small_array!(8 uniform8:
              0, 1, 2, 3, 4, 5, 6, 7);
 small_array!(9 uniform9:
              0, 1, 2, 3, 4, 5, 6, 7, 8);
 small_array!(10 uniform10:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
 small_array!(11 uniform11:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 small_array!(12 uniform12:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
 small_array!(13 uniform13:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 small_array!(14 uniform14:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
 small_array!(15 uniform15:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
 small_array!(16 uniform16:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 small_array!(17 uniform17:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
 small_array!(18 uniform18:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17);
 small_array!(19 uniform19:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18);
 small_array!(20 uniform20:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19);
 small_array!(21 uniform21:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20);
 small_array!(22 uniform22:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21);
 small_array!(23 uniform23:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22);
 small_array!(24 uniform24:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23);
 small_array!(25 uniform25:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24);
 small_array!(26 uniform26:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25);
 small_array!(27 uniform27:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26);
 small_array!(28 uniform28:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26, 27);
 small_array!(29 uniform29:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28);
 small_array!(30 uniform30:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29);
 small_array!(31 uniform31:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30);
 small_array!(32 uniform32:
              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
              18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);

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

     #[test]
     fn shrinks_fully_ltr() {
         fn pass(a: [i32; 2]) -> bool {
             a[0] * a[1] <= 9
         }

         let input = [0..32, 0..32];
         let mut runner = TestRunner::deterministic();

         let mut cases_tested = 0;
         for _ in 0..256 {
             // Find a failing test case
             let mut case = input.new_tree(&mut runner).unwrap();
             if pass(case.current()) {
                 continue;
             }

             loop {
                 if pass(case.current()) {
                     if !case.complicate() {
                         break;
                     }
                 } else {
                     if !case.simplify() {
                         break;
                     }
                 }
             }

             let last = case.current();
             assert!(!pass(last));
             // Maximally shrunken
             assert!(pass([last[0] - 1, last[1]]));
             assert!(pass([last[0], last[1] - 1]));

             cases_tested += 1;
         }

         assert!(cases_tested > 32, "Didn't find enough test cases");
     }

     #[test]
     fn test_sanity() {
         check_strategy_sanity([(0i32..1000), (1i32..1000)], 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.

	//! Support for strategies producing fixed-length arrays.
	//!
	//! An array of strategies (but only length 1 to 32 for now) is itself a
	//! strategy which generates arrays of that size drawing elements from the
	//! corresponding input strategies.
	//!
	//! See also [`UniformArrayStrategy`](struct.UniformArrayStrategy.html) for
	//! easily making a strategy for an array drawn from one strategy.
	//!
	//! General implementations are available for sizes 1 through 32.

	use core::marker::PhantomData;

	use crate::strategy::*;
	use crate::test_runner::*;

	/// A `Strategy` which generates fixed-size arrays containing values drawn from
	/// an inner strategy.
	///
	/// `T` must be an array type of length 1 to 32 whose values are produced by
	/// strategy `S`. Instances of this type are normally created by the various
	/// `uniformXX` functions in this module.
	///
	/// This is mainly useful when the inner strategy is not `Copy`, precluding
	/// expressing the strategy as `[myStrategy; 32]`, for example.
	///
	/// ## Example
	///
	/// ```
	/// use proptest::prelude::*;
	///
	/// proptest! {
	/// #[test]
	/// fn test_something(a in prop::array::uniform32(1u32..)) {
	/// let unexpected = [0u32;32];
	/// // `a` is also a [u32;32], so we can compare them directly
	/// assert_ne!(unexpected, a);
	/// }
	/// }
	/// # fn main() { }
	/// ```
	#[must_use = "strategies do nothing unless used"]
	#[derive(Clone, Copy, Debug)]
	pub struct UniformArrayStrategy<S, T> {
	strategy: S,
	_marker: PhantomData<T>,
	}

	impl<S, T> UniformArrayStrategy<S, T> {
	/// Directly create a `UniformArrayStrategy`.
	///
	/// This is only intended for advanced use, since the only way to specify
	/// the array size is with the turbofish operator and explicitly naming the
	/// type of the values in the array and the strategy itself.
	///
	/// Prefer the `uniformXX` functions at module-level unless something
	/// precludes their use.
	pub fn new(strategy: S) -> Self {
	UniformArrayStrategy {
	strategy,
	_marker: PhantomData,
	}
	}
	}

	/// A `ValueTree` operating over a fixed-size array.
	#[derive(Clone, Copy, Debug)]
	pub struct ArrayValueTree<T> {
	tree: T,
	shrinker: usize,
	last_shrinker: Option<usize>,
	}

	macro_rules! small_array {
	($n:tt $uni:ident : $($ix:expr),*) => {
	/// Create a strategy to generate fixed-length arrays.
	///
	/// All values within the new strategy are generated using the given
	/// strategy. The length of the array corresponds to the suffix of the
	/// name of this function.
	///
	/// See [`UniformArrayStrategy`](struct.UniformArrayStrategy.html) for
	/// example usage.
	pub fn $uni<S : Strategy>
	(strategy: S) -> UniformArrayStrategy<S, [S::Value; $n]>
	{
	UniformArrayStrategy {
	strategy,
	_marker: PhantomData
	}
	}

	impl<S : Strategy> Strategy for [S; $n] {
	type Tree = ArrayValueTree<[S::Tree; $n]>;
	type Value = [S::Value; $n];

	fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
	Ok(ArrayValueTree {
	tree: [$(self[$ix].new_tree(runner)?,)*],
	shrinker: 0,
	last_shrinker: None,
	})
	}
	}

	impl<S : Strategy> Strategy
	for UniformArrayStrategy<S, [S::Value; $n]> {
	type Tree = ArrayValueTree<[S::Tree; $n]>;
	type Value = [S::Value; $n];

	fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self> {
	Ok(ArrayValueTree {
	tree: [$({
	let _ = $ix;
	self.strategy.new_tree(runner)?
	},)*],
	shrinker: 0,
	last_shrinker: None,
	})
	}
	}

	impl<T : ValueTree> ValueTree for ArrayValueTree<[T;$n]> {
	type Value = [T::Value;$n];

	fn current(&self) -> [T::Value;$n] {
	[$(self.tree[$ix].current(),)*]
	}

	fn simplify(&mut self) -> bool {
	while self.shrinker < $n {
	if self.tree[self.shrinker].simplify() {
	self.last_shrinker = Some(self.shrinker);
	return true;
	} else {
	self.shrinker += 1;
	}
	}

	false
	}

	fn complicate(&mut self) -> bool {
	if let Some(shrinker) = self.last_shrinker {
	self.shrinker = shrinker;
	if self.tree[shrinker].complicate() {
	true
	} else {
	self.last_shrinker = None;
	false
	}
	} else {
	false
	}
	}
	}
	}
	}

	small_array!(1 uniform1:
	0);
	small_array!(2 uniform2:
	0, 1);
	small_array!(3 uniform3:
	0, 1, 2);
	small_array!(4 uniform4:
	0, 1, 2, 3);
	small_array!(5 uniform5:
	0, 1, 2, 3, 4);
	small_array!(6 uniform6:
	0, 1, 2, 3, 4, 5);
	small_array!(7 uniform7:
	0, 1, 2, 3, 4, 5, 6);
	small_array!(8 uniform8:
	0, 1, 2, 3, 4, 5, 6, 7);
	small_array!(9 uniform9:
	0, 1, 2, 3, 4, 5, 6, 7, 8);
	small_array!(10 uniform10:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
	small_array!(11 uniform11:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
	small_array!(12 uniform12:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
	small_array!(13 uniform13:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
	small_array!(14 uniform14:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
	small_array!(15 uniform15:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
	small_array!(16 uniform16:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
	small_array!(17 uniform17:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
	small_array!(18 uniform18:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17);
	small_array!(19 uniform19:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18);
	small_array!(20 uniform20:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19);
	small_array!(21 uniform21:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20);
	small_array!(22 uniform22:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21);
	small_array!(23 uniform23:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22);
	small_array!(24 uniform24:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23);
	small_array!(25 uniform25:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24);
	small_array!(26 uniform26:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25);
	small_array!(27 uniform27:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26);
	small_array!(28 uniform28:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26, 27);
	small_array!(29 uniform29:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28);
	small_array!(30 uniform30:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29);
	small_array!(31 uniform31:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30);
	small_array!(32 uniform32:
	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);

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

	#[test]
	fn shrinks_fully_ltr() {
	fn pass(a: [i32; 2]) -> bool {
	a[0] * a[1] <= 9
	}

	let input = [0..32, 0..32];
	let mut runner = TestRunner::deterministic();

	let mut cases_tested = 0;
	for _ in 0..256 {
	// Find a failing test case
	let mut case = input.new_tree(&mut runner).unwrap();
	if pass(case.current()) {
	continue;
	}

	loop {
	if pass(case.current()) {
	if !case.complicate() {
	break;
	}
	} else {
	if !case.simplify() {
	break;
	}
	}
	}

	let last = case.current();
	assert!(!pass(last));
	// Maximally shrunken
	assert!(pass([last[0] - 1, last[1]]));
	assert!(pass([last[0], last[1] - 1]));

	cases_tested += 1;
	}

	assert!(cases_tested > 32, "Didn't find enough test cases");
	}

	#[test]
	fn test_sanity() {
	check_strategy_sanity([(0i32..1000), (1i32..1000)], None);
	}
	}