rust_study0 0.1.1

First study project of RUST
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

use rust_study0::*;

trait TestCase {
    fn invoke(&self);
}

struct TestFunction<'a, T: FnOnce() -> () + Copy> {
    foo: &'a T,
    permit: bool,
}

impl<'a, T> TestCase for TestFunction<'a, T> where T: FnOnce() -> () + Copy, {
    fn invoke(&self) {
        if self.permit {
            (self.foo)();
        }
    }
}

impl<'a, T> TestFunction<'a, T> where T: FnOnce() -> () + Copy, {
    fn valid(foo: &'a T) -> TestFunction<'a, T> {
        TestFunction {
            foo: foo,
            permit: true,
        }
    }
    fn invalid(foo: &'a T) -> TestFunction<'a, T> {
        TestFunction {
            foo: foo,
            permit: false,
        }
    }
}

fn main() {
    let cases: Vec<Box<dyn TestCase>> = vec![
        Box::new(TestFunction::valid(&||{
            let chances = 3;
            match guess_number(true, chances).1 {
                true => println!("Succeed to guess the number"),
                false => println!("Failed to guess the number in {} times", chances)
            }
        })),
        Box::new(TestFunction::invalid(&||{
            let chances = 10;
            let (answer, result) = guess_number(false, chances);
            if result {
               println!("Succeed to guess the number");
            } else {
               println!("Failed to guess {} in {} times", answer, chances);
            }
        })),
        Box::new(TestFunction::invalid(&||{
            test_variables();
            test_const();
        })),
        Box::new(TestFunction::invalid(&test_types)),
        Box::new(TestFunction::invalid(&test_ownership)),
        Box::new(TestFunction::invalid(&test_struct)),
        Box::new(TestFunction::invalid(&test_enum)),
        Box::new(TestFunction::invalid(&|| {
            test_vector();
            test_string();
            test_hash();
        })),
        Box::new(TestFunction::invalid(&test_generic)),
        Box::new(TestFunction::valid(&|| {
            let args = test_arguments(); // get argument list
            let file_name = parse_arg(&args); // get file name from arguments
            if let Err(e) = test_file(&file_name) {
                eprintln!("{:?}", e);
            }
        })),
        Box::new(TestFunction::valid(&test_closure)),
    ];

    for case in cases {
        case.invoke();
    }
}