memsize 0.1.4

Memory unit sizes
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

use crate::units;

mod test {

    use super::*;

    #[test]
    fn test_calculate_size() {
        let k = units::MemoryUnit::Kilobyte;

        let four_k = k.size() * 4;
        assert_eq!(four_k, 4096);
        
        let four_k = k.decimal_size() * 4;
        assert_eq!(four_k, 4000);
    }


    #[test]
    fn test_parse() {
        let b: units::MemoryUnit = "b".parse().expect("Could not parse");
        assert_eq!(b, units::MemoryUnit::Byte);
        let b: units::MemoryUnit = "byte".parse().expect("Could not parse");
        assert_eq!(b, units::MemoryUnit::Byte);

        let kb: units::MemoryUnit = "kb".parse().expect("Could not parse");
        assert_eq!(kb, units::MemoryUnit::Kilobyte);
        let kb: units::MemoryUnit = "kilobyte".parse().expect("Could not parse");
        assert_eq!(kb, units::MemoryUnit::Kilobyte);

        let mb: units::MemoryUnit = "mb".parse().expect("Could not parse");
        assert_eq!(mb, units::MemoryUnit::Megabyte);
        let mb: units::MemoryUnit = "megabyte".parse().expect("Could not parse");
        assert_eq!(mb, units::MemoryUnit::Megabyte);

        let gb: units::MemoryUnit = "gb".parse().expect("Could not parse");
        assert_eq!(gb, units::MemoryUnit::Gigabyte);
        let gb: units::MemoryUnit = "gigabyte".parse().expect("Could not parse");
        assert_eq!(gb, units::MemoryUnit::Gigabyte);

        let tb: units::MemoryUnit = "tb".parse().expect("Could not parse");
        assert_eq!(tb, units::MemoryUnit::Terabyte);
        let tb: units::MemoryUnit = "terabyte".parse().expect("Could not parse");
        assert_eq!(tb, units::MemoryUnit::Terabyte);

        let pb: units::MemoryUnit = "pb".parse().expect("Could not parse");
        assert_eq!(pb, units::MemoryUnit::Petabyte);
        let pb: units::MemoryUnit = "petabyte".parse().expect("Could not parse");
        assert_eq!(pb, units::MemoryUnit::Petabyte);

        let eb: units::MemoryUnit = "eb".parse().expect("Could not parse");
        assert_eq!(eb, units::MemoryUnit::Exabyte);
        let eb: units::MemoryUnit = "exabyte".parse().expect("Could not parse");
        assert_eq!(eb, units::MemoryUnit::Exabyte);

        let zb: units::MemoryUnit = "zb".parse().expect("Could not parse");
        assert_eq!(zb, units::MemoryUnit::Zettabyte);
        let zb: units::MemoryUnit = "zettabyte".parse().expect("Could not parse");
        assert_eq!(zb, units::MemoryUnit::Zettabyte);

        let yb: units::MemoryUnit = "yb".parse().expect("Could not parse");
        assert_eq!(yb, units::MemoryUnit::Yottabyte);
        let yb: units::MemoryUnit = "yottabyte".parse().expect("Could not parse");
        assert_eq!(yb, units::MemoryUnit::Yottabyte);

        let unknown: Result<units::MemoryUnit, String> = "unknown".parse();
        match unknown {
            Ok(_) => panic!("Incorrectly parsed"),
            _ => {},
        }
        
    }
}