cryptor 0.1.0

Cryptor is encryption machine corresponding to the diversity of algorithms.
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
112
113
114
115
116
117
118
119


/// encrypter crate
extern crate cryptor;

#[cfg(test)]
mod router_manager_tests {

    use cryptor::cryptor::{ Router, RouterManager, SubstitutionTable };
    use cryptor::cryptor::{ ALPHABETS };

    #[test]
    fn incrementable() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        router_manager.increment();

        let expects = vec![1, 0, 0];
        for i in 0..3 {
            assert_eq!(expects[i], router_manager.routers[i].get_position());
        }
    }

    #[test]
    fn incrementable_digit_up() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        router_manager.routers[0].set_position(&'0');
        router_manager.routers[1].set_position(&'0');
        router_manager.routers[2].set_position(&'9');
        router_manager.increment();

        let expects = vec![0, 0, 95];
        for i in 0..3 {
            assert_eq!(expects[i], router_manager.routers[i].get_position());
        }
    }

    #[test]
    fn encryptable_to_reflector() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        let result = router_manager.crypto_to_reflector(&'A');
        assert_eq!('A', result);
    }

    #[test]
    fn encryptable_from_reflector() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        let result = router_manager.crypto_to_reflector(&'A');
        assert_eq!('A', result);
    }

    #[test]
    fn encryptable_to_reflector_after_increment() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        router_manager.increment();
        let result = router_manager.crypto_to_reflector(&'A');
        assert_eq!('B', result);
    }

    #[test]
    fn encryptable_from_reflector_after_increment() {

        #![allow(unused_mut)]
        let mut router_manager = RouterManager {
            routers: vec![
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec())),
                Router::new(SubstitutionTable::new(ALPHABETS.to_vec()))
            ]
        };

        router_manager.increment();
        let result = router_manager.crypto_from_reflector(&'a');
        assert_eq!('0', result);
    }
}