humfmt 0.6.0

Ergonomic human-readable formatting toolkit for 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
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use humfmt::{percent, percent_with, Humanize, PercentOptions};

// --- Basic rendering ---

#[test]
fn formats_common_ratios() {
    assert_eq!(percent(0.0_f64).to_string(), "0%");
    assert_eq!(percent(0.5_f64).to_string(), "50%");
    assert_eq!(percent(1.0_f64).to_string(), "100%");
}

#[test]
fn formats_fractional_ratio_with_default_precision() {
    assert_eq!(percent(0.423_f64).to_string(), "42.3%");
    assert_eq!(percent(0.4235_f64).to_string(), "42.4%");
}

#[test]
fn trims_trailing_zeros_by_default() {
    assert_eq!(percent(0.5_f64).to_string(), "50%");
    assert_eq!(percent(0.10_f64).to_string(), "10%");
    assert_eq!(percent(0.42_f64).to_string(), "42%");
}

// --- Precision ---

#[test]
fn supports_precision_override() {
    let opts = PercentOptions::new().precision(2);
    assert_eq!(percent_with(0.4236_f64, opts).to_string(), "42.36%");
    assert_eq!(percent_with(0.5_f64, opts).to_string(), "50%");
}

#[test]
fn precision_zero_rounds_to_integer() {
    let opts = PercentOptions::new().precision(0);
    assert_eq!(percent_with(0.424_f64, opts).to_string(), "42%");
    assert_eq!(percent_with(0.425_f64, opts).to_string(), "43%");
    assert_eq!(percent_with(0.426_f64, opts).to_string(), "43%");
}

// --- Fixed precision ---

#[test]
fn fixed_precision_preserves_trailing_zeros() {
    let opts = PercentOptions::new().precision(2).fixed_precision(true);
    assert_eq!(percent_with(0.5_f64, opts).to_string(), "50.00%");
    assert_eq!(percent_with(0.425_f64, opts).to_string(), "42.50%");
    assert_eq!(percent_with(0.4236_f64, opts).to_string(), "42.36%");
}

#[test]
fn fixed_precision_with_zero_precision_emits_no_decimal() {
    let opts = PercentOptions::new().precision(0).fixed_precision(true);
    assert_eq!(percent_with(0.424_f64, opts).to_string(), "42%");
    assert_eq!(percent_with(0.5_f64, opts).to_string(), "50%");
}

// --- Edge cases ---

#[test]
fn formats_zero() {
    assert_eq!(percent(0.0_f64).to_string(), "0%");
    assert_eq!(percent(-0.0_f64).to_string(), "0%");
}

#[test]
fn formats_one_hundred_percent() {
    assert_eq!(percent(1.0_f64).to_string(), "100%");
}

#[test]
fn formats_values_above_one() {
    assert_eq!(percent(1.5_f64).to_string(), "150%");
    assert_eq!(percent(2.0_f64).to_string(), "200%");
}

#[test]
fn formats_negative_ratios() {
    assert_eq!(percent(-0.5_f64).to_string(), "-50%");
    assert_eq!(percent(-0.423_f64).to_string(), "-42.3%");
}

#[test]
fn negative_value_rounding_to_zero_suppresses_minus() {
    assert_eq!(percent(-0.0004_f64).to_string(), "0%");
}

#[test]
fn preserves_non_finite_values() {
    assert_eq!(percent(f64::INFINITY).to_string(), "inf%");
    assert_eq!(percent(f64::NEG_INFINITY).to_string(), "-inf%");
    assert_eq!(percent(f64::NAN).to_string(), "NaN%");
}

#[test]
fn supports_f32_input() {
    assert_eq!(percent(0.5_f32).to_string(), "50%");
    assert_eq!(percent(1.0_f32).to_string(), "100%");
}

// --- Custom decimal separator ---

#[test]
fn supports_custom_decimal_separator() {
    let opts = PercentOptions::new().precision(1).decimal_separator(',');
    assert_eq!(percent_with(0.423_f64, opts).to_string(), "42,3%");
}

// --- Extension trait ---

#[test]
fn supports_extension_trait_usage() {
    assert_eq!(0.423_f64.human_percent().to_string(), "42.3%");
    assert_eq!(1.0_f64.human_percent().to_string(), "100%");
}

#[test]
fn supports_extension_trait_with_options() {
    let opts = PercentOptions::new().precision(2).fixed_precision(true);
    assert_eq!(0.5_f64.human_percent_with(opts).to_string(), "50.00%");
}

// --- Rounding ---

#[test]
fn half_up_rounding() {
    let opts = PercentOptions::new().precision(1);
    assert_eq!(percent_with(0.4250_f64, opts).to_string(), "42.5%");
    assert_eq!(percent_with(0.4255_f64, opts).to_string(), "42.6%");
    assert_eq!(percent_with(0.4244_f64, opts).to_string(), "42.4%");
}

#[test]
fn sign_symmetry() {
    let test_values: &[f64] = &[0.1, 0.25, 0.5, 0.75, 1.0, 1.5];
    for &v in test_values {
        let pos = percent(v).to_string();
        let neg = percent(-v).to_string();
        assert_eq!(neg, format!("-{pos}"), "sign symmetry failed for {v}");
    }
}

#[test]
fn force_sign_renders_plus_for_positive_percents() {
    let opts = PercentOptions::new().force_sign(true);
    assert_eq!(percent_with(0.42_f64, opts).to_string(), "+42%");
    assert_eq!(percent_with(0.0_f64, opts).to_string(), "0%");
    assert_eq!(percent_with(-0.42_f64, opts).to_string(), "-42%");
}

#[test]
fn force_sign_avoids_plus_zero_when_rounding() {
    let opts = PercentOptions::new().force_sign(true).precision(1);
    assert_eq!(percent_with(0.0004_f64, opts).to_string(), "0%");
}