smoke 0.4.0

A framework for testing
Documentation 
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! string based generator types

use super::super::rand::R;
use super::base::{BoxGenerator, Generator};
use super::numerical::range;

/// Generate String containing only ASCII characters
pub struct AsciiString(BoxGenerator<usize>);

impl Generator for AsciiString {
    type Item = String;

    fn generate(&self, r: &mut R) -> Self::Item {
        let sz = self.0.generate(&mut r.sub());
        let mut chars_r = r.sub();
        let mut out = Vec::with_capacity(sz);
        let ascii_range = range(0x20..0x7f).map(|n| std::char::from_u32(n).unwrap());
        for _ in 0..sz {
            out.push(ascii_range.generate(&mut chars_r))
        }
        out.iter().collect()
    }
}

/// generate ASCII string of size specified by the generator in parameter
///
/// ```
/// use smoke::generator::{string::ascii, constant, range};
///
/// let fixed_size_string = ascii(constant(12));
/// let small_string = ascii(range(1..8));
/// ```
pub fn ascii<SZ: Generator<Item = usize> + 'static>(size: SZ) -> AsciiString {
    AsciiString(size.into_boxed())
}

/// Generate String of size specified by the first generator and of character range
/// specified by the second generator
pub struct StringGenerator(BoxGenerator<usize>, BoxGenerator<char>);

impl Generator for StringGenerator {
    type Item = String;

    fn generate(&self, r: &mut R) -> Self::Item {
        let sz = self.0.generate(&mut r.sub());
        let mut chars_r = r.sub();
        let mut out = Vec::with_capacity(sz);
        for _ in 0..sz {
            out.push(self.1.generate(&mut chars_r))
        }
        out.iter().collect()
    }
}

/// generate arbitary string of size specified by the first generator in parameter
/// and character set specified by the character generator
///
/// ```
/// use smoke::generator::{string::string, constant, range};
///
/// let four_digits_string = string(constant(4), range('0'..'9'));
/// let small_letters = string(range(1..8), range('a'..'z'));
/// ```
pub fn string<SZ: Generator<Item = usize> + 'static, C: Generator<Item = char> + 'static>(
    size: SZ,
    chars: C,
) -> StringGenerator {
    StringGenerator(size.into_boxed(), chars.into_boxed())
}