azul-css 0.0.7

Common datatypes used for styling applications using the Azul desktop GUI framework
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268

//! CSS Property Resolution Tests
//!
//! Tests for em, rem, percentage, and other CSS unit resolution.

use azul_css::props::basic::{length::SizeMetric, pixel::PixelValue};

#[test]
fn test_pixel_value_px() {
    let value = PixelValue::px(100.0);
    assert_eq!(value.metric, SizeMetric::Px);
    assert!((value.number.get() - 100.0).abs() < 0.001);
}

#[test]
fn test_pixel_value_em() {
    let value = PixelValue::em(2.0);
    assert_eq!(value.metric, SizeMetric::Em);
    assert!((value.number.get() - 2.0).abs() < 0.001);
}

#[test]
fn test_pixel_value_rem() {
    let value = PixelValue::rem(1.5);
    assert_eq!(value.metric, SizeMetric::Rem);
    assert!((value.number.get() - 1.5).abs() < 0.001);
}

#[test]
fn test_pixel_value_percent() {
    let value = PixelValue::percent(50.0);
    assert_eq!(value.metric, SizeMetric::Percent);
    assert!((value.number.get() - 50.0).abs() < 0.001);
}

#[test]
fn test_pixel_value_pt() {
    let value = PixelValue::pt(12.0);
    assert_eq!(value.metric, SizeMetric::Pt);
    assert!((value.number.get() - 12.0).abs() < 0.001);
}

#[test]
fn test_to_pixels_internal_px() {
    let value = PixelValue::px(100.0);
    let result = value.to_pixels_internal(50.0, 16.0);
    assert!((result - 100.0).abs() < 0.001, "Px should return raw value");
}

#[test]
fn test_to_pixels_internal_em() {
    let value = PixelValue::em(2.0);
    let result = value.to_pixels_internal(50.0, 16.0);
    // em uses em_resolve parameter
    assert!((result - 32.0).abs() < 0.001, "2em with 16px base = 32px");
}

#[test]
fn test_to_pixels_internal_percent() {
    let value = PixelValue::percent(50.0);
    let result = value.to_pixels_internal(200.0, 16.0);
    // percent uses percent_resolve parameter
    assert!((result - 100.0).abs() < 0.001, "50% of 200 = 100");
}

#[test]
fn test_to_pixels_internal_pt() {
    let value = PixelValue::pt(12.0);
    let result = value.to_pixels_internal(50.0, 16.0);
    // 1pt = 1.333... px (96/72)
    let expected = 12.0 * (96.0 / 72.0);
    assert!((result - expected).abs() < 0.1, "12pt should be ~16px");
}

#[test]
fn test_pixel_value_zero() {
    let value = PixelValue::px(0.0);
    let result = value.to_pixels_internal(100.0, 100.0);
    assert!((result - 0.0).abs() < 0.001);
}

#[test]
fn test_pixel_value_negative() {
    let value = PixelValue::px(-10.0);
    let result = value.to_pixels_internal(100.0, 100.0);
    assert!((result - (-10.0)).abs() < 0.001);
}

#[test]
fn test_pixel_value_large() {
    let value = PixelValue::px(10000.0);
    let result = value.to_pixels_internal(100.0, 100.0);
    assert!((result - 10000.0).abs() < 0.001);
}

#[test]
fn test_pixel_value_small_fraction() {
    let value = PixelValue::px(0.5);
    let result = value.to_pixels_internal(100.0, 100.0);
    assert!((result - 0.5).abs() < 0.001);
}

#[test]
fn test_em_chain_resolution() {
    // Simulate: root = 16px, parent = 2em (32px), child = 1.5em
    // Child's 1.5em should resolve against parent's 32px = 48px
    let parent_em = PixelValue::em(2.0);
    let parent_px = parent_em.to_pixels_internal(100.0, 16.0); // 2 * 16 = 32
    assert!((parent_px - 32.0).abs() < 0.001);

    let child_em = PixelValue::em(1.5);
    let child_px = child_em.to_pixels_internal(100.0, parent_px); // 1.5 * 32 = 48
    assert!((child_px - 48.0).abs() < 0.001);
}

#[test]
fn test_percent_100() {
    let value = PixelValue::percent(100.0);
    let result = value.to_pixels_internal(200.0, 16.0);
    assert!((result - 200.0).abs() < 0.001, "100% of 200 = 200");
}

#[test]
fn test_percent_over_100() {
    let value = PixelValue::percent(150.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!((result - 150.0).abs() < 0.001, "150% of 100 = 150");
}

#[test]
fn test_em_fractional() {
    let value = PixelValue::em(0.875); // Common value for smaller text
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!(
        (result - 14.0).abs() < 0.001,
        "0.875em with 16px base = 14px"
    );
}

#[test]
fn test_inch_to_pixels() {
    // 1 inch = 96 CSS pixels
    let value = PixelValue::inch(1.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!((result - 96.0).abs() < 0.1, "1in = 96px");
}

#[test]
fn test_cm_to_pixels() {
    // 1 cm = 96/2.54 ≈ 37.8 CSS pixels
    let value = PixelValue::cm(1.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    let expected = 96.0 / 2.54;
    assert!((result - expected).abs() < 0.1, "1cm ≈ 37.8px");
}

#[test]
fn test_mm_to_pixels() {
    // 1 mm = 96/25.4 ≈ 3.78 CSS pixels
    let value = PixelValue::mm(1.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    let expected = 96.0 / 25.4;
    assert!((result - expected).abs() < 0.1, "1mm ≈ 3.78px");
}

#[test]
fn test_viewport_units_return_zero_without_context() {
    // Viewport units cannot be resolved without viewport context
    let vw = PixelValue::from_metric(SizeMetric::Vw, 100.0);
    let vh = PixelValue::from_metric(SizeMetric::Vh, 100.0);
    let vmin = PixelValue::from_metric(SizeMetric::Vmin, 100.0);
    let vmax = PixelValue::from_metric(SizeMetric::Vmax, 100.0);

    // to_pixels_internal returns 0 for viewport units (needs layout context)
    assert_eq!(vw.to_pixels_internal(100.0, 16.0), 0.0);
    assert_eq!(vh.to_pixels_internal(100.0, 16.0), 0.0);
    assert_eq!(vmin.to_pixels_internal(100.0, 16.0), 0.0);
    assert_eq!(vmax.to_pixels_internal(100.0, 16.0), 0.0);
}

#[test]
fn test_size_metric_equality() {
    assert_eq!(SizeMetric::Px, SizeMetric::Px);
    assert_eq!(SizeMetric::Em, SizeMetric::Em);
    assert_ne!(SizeMetric::Px, SizeMetric::Em);
}

#[test]
fn test_pixel_value_equality() {
    let a = PixelValue::px(10.0);
    let b = PixelValue::px(10.0);
    let c = PixelValue::px(20.0);
    let d = PixelValue::em(10.0);

    assert_eq!(a, b);
    assert_ne!(a, c);
    assert_ne!(a, d);
}

#[test]
fn test_default_font_size_constant() {
    // CSS spec: default font-size is 16px
    let default_em = PixelValue::em(1.0);
    let result = default_em.to_pixels_internal(100.0, 16.0);
    assert!(
        (result - 16.0).abs() < 0.001,
        "1em with default 16px = 16px"
    );
}

#[test]
fn test_rem_uses_em_resolve() {
    // In to_pixels_internal, rem also uses em_resolve
    // (proper rem resolution requires root font-size context)
    let value = PixelValue::rem(2.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!(
        (result - 32.0).abs() < 0.001,
        "2rem with 16px em_resolve = 32px"
    );
}

#[test]
fn test_mixed_calculations() {
    // Simulate a realistic scenario:
    // Container: 500px wide
    // Padding: 5% = 25px
    // Font: 1.25em with 16px base = 20px

    let container_width = 500.0;
    let base_font = 16.0;

    let padding = PixelValue::percent(5.0);
    let padding_px = padding.to_pixels_internal(container_width, base_font);
    assert!((padding_px - 25.0).abs() < 0.001);

    let font = PixelValue::em(1.25);
    let font_px = font.to_pixels_internal(container_width, base_font);
    assert!((font_px - 20.0).abs() < 0.001);
}

// Edge cases for numerical precision
#[test]
fn test_very_small_em() {
    let value = PixelValue::em(0.001);
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!((result - 0.016).abs() < 0.001);
}

#[test]
fn test_very_large_em() {
    let value = PixelValue::em(100.0);
    let result = value.to_pixels_internal(100.0, 16.0);
    assert!((result - 1600.0).abs() < 0.001);
}

#[test]
fn test_percent_with_zero_base() {
    let value = PixelValue::percent(50.0);
    let result = value.to_pixels_internal(0.0, 16.0);
    assert!((result - 0.0).abs() < 0.001, "50% of 0 = 0");
}

#[test]
fn test_em_with_zero_base() {
    let value = PixelValue::em(2.0);
    let result = value.to_pixels_internal(100.0, 0.0);
    assert!((result - 0.0).abs() < 0.001, "2em with 0px base = 0");
}