gazbuzz 0.1.5

A library crate offering functions related to FizzBuzz.
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

#[allow(dead_code)]
pub mod fizzbuzz
{
    /// Check if a number is fizz. `false` on fizzbuzz.
    pub fn is_fizz(n: i32) -> bool
    {
        n.abs() % 3 == 0 && !is_fizzbuzz(n)
    }

    /// Check if a number is buzz. `false` on fizzbuzz.
    pub fn is_buzz(n: i32) -> bool
    {
        n.abs() % 5 == 0 && !is_fizzbuzz(n)
    }

    /// Check if a number is fizzbuzz.
    pub fn is_fizzbuzz(n: i32) -> bool
    {
        n.abs() % 15 == 0
    }

    /// Check if a number is not fizz, buzz, or fizzbuzz.
    pub fn is_none(n: i32) -> bool
    {
        !is_fizz(n) && !is_buzz(n) && !is_fizzbuzz(n)
    }

    /// Check a number against fizz, buzz, and fizzbuzz, as per the usual
    /// requirements of a typical fizzbuzz implementation.
    pub fn check(n: i32) -> String
    {
        if is_fizzbuzz(n)
        {
            return "fizzbuzz".to_string();
        }

        if is_fizz(n)
        {
            return "fizz".to_string();
        }

        if is_buzz(n)
        {
            return "buzz".to_string();
        }

        n.to_string()
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn detects_fizz()
    {
        assert!(fizzbuzz::is_fizz(3));
        assert!(fizzbuzz::is_fizz(6));
        assert!(!fizzbuzz::is_fizz(15));
    }

    #[test]
    fn detects_buzz()
    {
        assert!(fizzbuzz::is_buzz(5));
        assert!(fizzbuzz::is_buzz(10));
        assert!(!fizzbuzz::is_buzz(15));
    }

    #[test]
    fn detects_fizzbuzz()
    {
        assert!(fizzbuzz::is_fizzbuzz(15));
        assert!(fizzbuzz::is_fizzbuzz(30));
        assert!(!fizzbuzz::is_fizzbuzz(33));
    }

    #[test]
    fn detects_none()
    {
        assert!(fizzbuzz::is_none(17));
        assert!(!fizzbuzz::is_none(3));
        assert!(!fizzbuzz::is_none(5));
        assert!(!fizzbuzz::is_none(15));
    }

    #[test]
    fn checks_from_negative_30_to_positive_30()
    {
        let expected = vec![
            "fizzbuzz", "-29", "-28", "fizz", "-26", "buzz", "fizz", "-23", "-22", "fizz",
            "buzz", "-19", "fizz", "-17", "-16", "fizzbuzz", "-14", "-13", "fizz", "-11",
            "buzz", "fizz", "-8", "-7", "fizz", "buzz", "-4", "fizz", "-2", "-1",
            "fizzbuzz", // 0
            "1", "2", "fizz", "4", "buzz", "fizz", "7", "8", "fizz", "buzz",
            "11", "fizz", "13", "14", "fizzbuzz", "16", "17", "fizz", "19", "buzz",
            "fizz", "22", "23", "fizz", "buzz", "26", "fizz", "28", "29", "fizzbuzz",
        ];

        let mut results: Vec<String> = vec![];

        for n in -30..=30
        {
            results.push(fizzbuzz::check(n));
        }

        assert_eq!(results, expected);
    }
}