Struct TextGenerator 

pub struct TextGenerator { /* private fields */ }

Generator for Unicode text strings. Created by text().

Implementations

impl TextGenerator

pub fn min_size(self, min_size: usize) -> Self

Set the minimum length in characters.

Examples found in repository

examples/ledger.rs (line 51)

    fn create_account(&mut self, tc: TestCase) {
        let account = tc.draw(gs::text().min_size(1));
        tc.note(&format!("create account '{}'", account.clone()));
        self.accounts.add(account);
    }

pub fn max_size(self, max_size: usize) -> Self

Set the maximum length in characters.

pub fn alphabet(self, chars: &str) -> Self

Use a fixed set of characters. Each character in the generated string will be a member of the alphabet.

Mutually exclusive with the character filtering methods like codec, categories, min_codepoint, etc.

pub fn codec(self, codec: &str) -> Self

Restrict to characters encodable in this codec (e.g. "ascii", "utf-8", "latin-1").

pub fn min_codepoint(self, min_codepoint: u32) -> Self

Set the minimum Unicode codepoint.

pub fn max_codepoint(self, max_codepoint: u32) -> Self

Set the maximum Unicode codepoint.

pub fn categories(self, categories: &[&str]) -> Self

Include only characters from these Unicode general categories (e.g. ["L", "Nd"]).

Mutually exclusive with exclude_categories.

pub fn exclude_categories(self, exclude_categories: &[&str]) -> Self

Exclude characters from these Unicode general categories.

Mutually exclusive with categories.

pub fn include_characters(self, include_characters: &str) -> Self

Always include these specific characters, even if excluded by other filters.

pub fn exclude_characters(self, exclude_characters: &str) -> Self

Always exclude these specific characters.

Trait Implementations

impl Generator<String> for TextGenerator

fn map<U, F>(self, f: F) -> Mapped<T, U, F, Self>

where Self: Sized, F: Fn(T) -> U + Send + Sync,

Transform generated values using a function.

fn flat_map<U, G, F>(self, f: F) -> FlatMapped<T, U, G, F, Self>

where Self: Sized, G: Generator<U>, F: Fn(T) -> G + Send + Sync,

Generate a value, then use it to choose or configure another generator.

fn filter<F>(self, predicate: F) -> Filtered<T, F, Self>

where Self: Sized, F: Fn(&T) -> bool + Send + Sync,

Only keep generated values that satisfy the predicate.

fn boxed<'a>(self) -> BoxedGenerator<'a, T>

where Self: Sized + Send + Sync + 'a,

Convert this generator into a type-erased boxed generator.