Struct proptest::char::CharStrategy

#[must_use = "strategies do nothing unless used"]pub struct CharStrategy<'a> { /* fields omitted */ }

Strategy for generating chars.

Character selection is more sophisticated than integer selection. Naïve selection (particularly in the larger context of generating strings) would result in starting inputs like ꂡ螧轎ቶᢹ糦狥芹ᘆ㶏曊ᒀ踔虙ჲ and "simplified" inputs consisting mostly of control characters. It also has difficulty locating edge cases, since the vast majority of code points (such as the enormous CJK regions) don't cause problems for anything with even basic Unicode support.

Instead, character selection is always based on explicit ranges, and is designed to bias to specifically chosen characters and character ranges to produce inputs that are both more useful and easier for humans to understand. There are also hard-wired simplification targets based on ASCII instead of simply simplifying towards NUL to avoid problematic inputs being reduced to a bunch of NUL characters.

Shrinking never crosses ranges. If you have a complex range like [A-Za-z] and the starting point x is chosen, it will not shrink to the first A-Z group, but rather simply to a.

The usual way to get instances of this class is with the module-level ANY constant or range function. Directly constructing a CharStrategy is only necessary for complex ranges or to override the default biases.

Implementations

impl<'a> CharStrategy<'a>

pub fn new(
    special: Cow<'a, [char]>,
    preferred: Cow<'a, [RangeInclusive<char>]>,
    ranges: Cow<'a, [RangeInclusive<char>]>
) -> Self

Construct a new CharStrategy with the parameters it will pass to the function underlying select_char().

All arguments as per select_char().

pub fn new_borrowed(
    special: &'a [char],
    preferred: &'a [RangeInclusive<char>],
    ranges: &'a [RangeInclusive<char>]
) -> Self

Same as CharStrategy::new() but using Cow::Borrowed for all parts.

Trait Implementations

impl<'a> Clone for CharStrategy<'a>

fn clone(&self) -> CharStrategy<'a>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for CharStrategy<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Strategy for CharStrategy<'a>

type Tree = CharValueTree

The value tree generated by this Strategy.

type Value = char

The type of value used by functions under test generated by this Strategy.

fn new_tree(&self, runner: &mut TestRunner) -> NewTree<Self>

Generate a new value tree from the given runner.

fn prop_map<O: Debug, F: Fn(Self::Value) -> O>(self, fun: F) -> Map<Self, F> where
    Self: Sized, 

Returns a strategy which produces values transformed by the function fun.

fn prop_map_into<O: Debug>(self) -> MapInto<Self, O> where
    Self: Sized,
    Self::Value: Into<O>, 

Returns a strategy which produces values of type O by transforming Self with Into<O>.

fn prop_perturb<O: Debug, F: Fn(Self::Value, TestRng) -> O>(
    self,
    fun: F
) -> Perturb<Self, F> where
    Self: Sized, 

Returns a strategy which produces values transformed by the function fun, which is additionally given a random number generator.

fn prop_flat_map<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> Flatten<Map<Self, F>> where
    Self: Sized, 

Maps values produced by this strategy into new strategies and picks values from those strategies.

fn prop_ind_flat_map<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlatten<Map<Self, F>> where
    Self: Sized, 

Maps values produced by this strategy into new strategies and picks values from those strategies while considering the new strategies to be independent.

fn prop_ind_flat_map2<S: Strategy, F: Fn(Self::Value) -> S>(
    self,
    fun: F
) -> IndFlattenMap<Self, F> where
    Self: Sized, 

Similar to prop_ind_flat_map(), but produces 2-tuples with the input generated from self in slot 0 and the derived strategy in slot 1.

fn prop_filter<R: Into<Reason>, F: Fn(&Self::Value) -> bool>(
    self,
    whence: R,
    fun: F
) -> Filter<Self, F> where
    Self: Sized, 

Returns a strategy which only produces values accepted by fun.

fn prop_filter_map<F: Fn(Self::Value) -> Option<O>, O: Debug>(
    self,
    whence: impl Into<Reason>,
    fun: F
) -> FilterMap<Self, F> where
    Self: Sized, 

Returns a strategy which only produces transformed values where fun returns Some(value) and rejects those where fun returns None.

fn prop_union(self, other: Self) -> Union<Self> where
    Self: Sized, 

Returns a strategy which picks uniformly from self and other.

fn prop_recursive<R: Strategy<Value = Self::Value> + 'static, F: Fn(BoxedStrategy<Self::Value>) -> R>(
    self,
    depth: u32,
    desired_size: u32,
    expected_branch_size: u32,
    recurse: F
) -> Recursive<Self::Value, F> where
    Self: Sized + 'static, 

Generate a recursive structure with self items as leaves.

fn prop_shuffle(self) -> Shuffle<Self> where
    Self: Sized,
    Self::Value: Shuffleable, 

Shuffle the contents of the values produced by this strategy.

fn boxed(self) -> BoxedStrategy<Self::Value> where
    Self: Sized + 'static, 

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn sboxed(self) -> SBoxedStrategy<Self::Value> where
    Self: Sized + Send + Sync + 'static, 

Erases the type of this Strategy so it can be passed around as a simple trait object.

fn no_shrink(self) -> NoShrink<Self> where
    Self: Sized, 

Wraps this strategy to prevent values from being subject to shrinking.