pretty-bytes-rust 0.3.0

Rust library that takes a number that represent a byte and returns a string that is prettier to read for a human
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

use pretty_bytes_rust::pretty_bytes;
use pretty_bytes_rust::PrettyBytesOptions;

#[test]
fn pretty_bytes_no_option1() {
    let result = pretty_bytes(1023, None);
    assert_eq!(result, "1023.00 B");
}

#[test]
fn pretty_bytes_no_option2() {
    let result = pretty_bytes(1024, None);
    assert_eq!(result, "1.00 kbit");
}

#[test]
fn pretty_bytes_option1() {
    let result = pretty_bytes(
        1024 * 1024 * 3,
        Some(PrettyBytesOptions {
            use_1024_instead_of_1000: None,
            number_of_decimal: Some(3),
            remove_zero_decimal: None,
        }),
    );
    assert_eq!(result, "3.000 Mbit");
}

#[test]
fn pretty_bytes_option2() {
    let result = pretty_bytes(
        1024 * 1024 * 3,
        Some(PrettyBytesOptions {
            use_1024_instead_of_1000: None,
            number_of_decimal: Some(3),
            remove_zero_decimal: Some(true),
        }),
    );
    assert_eq!(result, "3 Mbit");
}

#[test]
fn pretty_bytes_option3() {
    let result = pretty_bytes(
        1024 * 1024 * 3,
        Some(PrettyBytesOptions {
            use_1024_instead_of_1000: Some(false),
            number_of_decimal: Some(3),
            remove_zero_decimal: Some(false),
        }),
    );
    assert_eq!(result, "3.146 MB");
}

#[test]
fn pretty_bytes_option4() {
    let r2 = pretty_bytes(
        1024 * 1024 * 8 + 123,
        Some(PrettyBytesOptions {
            use_1024_instead_of_1000: Some(false),
            number_of_decimal: None,
            remove_zero_decimal: Some(false),
        }),
    );
    assert_eq!(r2, "8.39 MB");
}

#[test]
fn pretty_bytes_64bits() {
    let r2 = pretty_bytes(18446744071562067968, None);
    assert_eq!(r2, "16.00 Ebit");
}

#[test]
fn pretty_bytes_zero() {
    let r2 = pretty_bytes(0, None);
    assert_eq!(r2, "0.00 B");
}