]> git.proxmox.com Git - rustc.git/blame - library/core/tests/time.rs
projects / rustc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New upstream version 1.74.1+dfsg1
[rustc.git] / library / core / tests / time.rs
CommitLineData
83c7162d
XL		 1use core::time::Duration;
2
3#[test]
4fn creation() {
416331ca 5 assert_ne!(Duration::from_secs(1), Duration::from_secs(0));
60c5eb7d
XL		 6 assert_eq!(Duration::from_secs(1) + Duration::from_secs(2), Duration::from_secs(3));
7 assert_eq!(
8 Duration::from_millis(10) + Duration::from_secs(4),
9 Duration::new(4, 10 * 1_000_000)
10 );
83c7162d
XL		 11 assert_eq!(Duration::from_millis(4000), Duration::new(4, 0));
12}
13
74b04a01
XL		 14#[test]
15#[should_panic]
16fn new_overflow() {
ba9703b0 17 let _ = Duration::new(u64::MAX, 1_000_000_000);
74b04a01
XL		 18}
19
83c7162d
XL		 20#[test]
21fn secs() {
22 assert_eq!(Duration::new(0, 0).as_secs(), 0);
94b46f34
XL		 23 assert_eq!(Duration::new(0, 500_000_005).as_secs(), 0);
24 assert_eq!(Duration::new(0, 1_050_000_001).as_secs(), 1);
83c7162d
XL		 25 assert_eq!(Duration::from_secs(1).as_secs(), 1);
26 assert_eq!(Duration::from_millis(999).as_secs(), 0);
27 assert_eq!(Duration::from_millis(1001).as_secs(), 1);
94b46f34
XL		 28 assert_eq!(Duration::from_micros(999_999).as_secs(), 0);
29 assert_eq!(Duration::from_micros(1_000_001).as_secs(), 1);
30 assert_eq!(Duration::from_nanos(999_999_999).as_secs(), 0);
31 assert_eq!(Duration::from_nanos(1_000_000_001).as_secs(), 1);
32}
33
34#[test]
35fn millis() {
36 assert_eq!(Duration::new(0, 0).subsec_millis(), 0);
37 assert_eq!(Duration::new(0, 500_000_005).subsec_millis(), 500);
38 assert_eq!(Duration::new(0, 1_050_000_001).subsec_millis(), 50);
39 assert_eq!(Duration::from_secs(1).subsec_millis(), 0);
40 assert_eq!(Duration::from_millis(999).subsec_millis(), 999);
41 assert_eq!(Duration::from_millis(1001).subsec_millis(), 1);
42 assert_eq!(Duration::from_micros(999_999).subsec_millis(), 999);
43 assert_eq!(Duration::from_micros(1_001_000).subsec_millis(), 1);
44 assert_eq!(Duration::from_nanos(999_999_999).subsec_millis(), 999);
45 assert_eq!(Duration::from_nanos(1_001_000_000).subsec_millis(), 1);
46}
47
48#[test]
49fn micros() {
50 assert_eq!(Duration::new(0, 0).subsec_micros(), 0);
51 assert_eq!(Duration::new(0, 500_000_005).subsec_micros(), 500_000);
52 assert_eq!(Duration::new(0, 1_050_000_001).subsec_micros(), 50_000);
53 assert_eq!(Duration::from_secs(1).subsec_micros(), 0);
54 assert_eq!(Duration::from_millis(999).subsec_micros(), 999_000);
55 assert_eq!(Duration::from_millis(1001).subsec_micros(), 1_000);
56 assert_eq!(Duration::from_micros(999_999).subsec_micros(), 999_999);
57 assert_eq!(Duration::from_micros(1_000_001).subsec_micros(), 1);
58 assert_eq!(Duration::from_nanos(999_999_999).subsec_micros(), 999_999);
59 assert_eq!(Duration::from_nanos(1_000_001_000).subsec_micros(), 1);
83c7162d
XL		 60}
61
62#[test]
63fn nanos() {
64 assert_eq!(Duration::new(0, 0).subsec_nanos(), 0);
65 assert_eq!(Duration::new(0, 5).subsec_nanos(), 5);
66 assert_eq!(Duration::new(0, 1_000_000_001).subsec_nanos(), 1);
67 assert_eq!(Duration::from_secs(1).subsec_nanos(), 0);
94b46f34
XL		 68 assert_eq!(Duration::from_millis(999).subsec_nanos(), 999_000_000);
69 assert_eq!(Duration::from_millis(1001).subsec_nanos(), 1_000_000);
70 assert_eq!(Duration::from_micros(999_999).subsec_nanos(), 999_999_000);
71 assert_eq!(Duration::from_micros(1_000_001).subsec_nanos(), 1000);
72 assert_eq!(Duration::from_nanos(999_999_999).subsec_nanos(), 999_999_999);
73 assert_eq!(Duration::from_nanos(1_000_000_001).subsec_nanos(), 1);
83c7162d
XL		 74}
75
76#[test]
77fn add() {
60c5eb7d
XL		 78 assert_eq!(Duration::new(0, 0) + Duration::new(0, 1), Duration::new(0, 1));
79 assert_eq!(Duration::new(0, 500_000_000) + Duration::new(0, 500_000_001), Duration::new(1, 1));
83c7162d
XL		 80}
81
82#[test]
83fn checked_add() {
60c5eb7d
XL		 84 assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));
85 assert_eq!(
86 Duration::new(0, 500_000_000).checked_add(Duration::new(0, 500_000_001)),
87 Some(Duration::new(1, 1))
88 );
ba9703b0 89 assert_eq!(Duration::new(1, 0).checked_add(Duration::new(u64::MAX, 0)), None);
83c7162d
XL		 90}
91
1b1a35ee
XL		 92#[test]
93fn saturating_add() {
94 assert_eq!(Duration::new(0, 0).saturating_add(Duration::new(0, 1)), Duration::new(0, 1));
95 assert_eq!(
96 Duration::new(0, 500_000_000).saturating_add(Duration::new(0, 500_000_001)),
97 Duration::new(1, 1)
98 );
99 assert_eq!(Duration::new(1, 0).saturating_add(Duration::new(u64::MAX, 0)), Duration::MAX);
100}
101
83c7162d
XL		 102#[test]
103fn sub() {
60c5eb7d
XL		 104 assert_eq!(Duration::new(0, 1) - Duration::new(0, 0), Duration::new(0, 1));
105 assert_eq!(Duration::new(0, 500_000_001) - Duration::new(0, 500_000_000), Duration::new(0, 1));
106 assert_eq!(Duration::new(1, 0) - Duration::new(0, 1), Duration::new(0, 999_999_999));
83c7162d
XL		 107}
108
109#[test]
110fn checked_sub() {
29967ef6
XL		 111 assert_eq!(Duration::NANOSECOND.checked_sub(Duration::ZERO), Some(Duration::NANOSECOND));
112 assert_eq!(
113 Duration::SECOND.checked_sub(Duration::NANOSECOND),
114 Some(Duration::new(0, 999_999_999))
115 );
116 assert_eq!(Duration::ZERO.checked_sub(Duration::NANOSECOND), None);
117 assert_eq!(Duration::ZERO.checked_sub(Duration::SECOND), None);
83c7162d
XL		 118}
119
1b1a35ee
XL		 120#[test]
121fn saturating_sub() {
29967ef6
XL		 122 assert_eq!(Duration::NANOSECOND.saturating_sub(Duration::ZERO), Duration::NANOSECOND);
123 assert_eq!(
124 Duration::SECOND.saturating_sub(Duration::NANOSECOND),
125 Duration::new(0, 999_999_999)
126 );
127 assert_eq!(Duration::ZERO.saturating_sub(Duration::NANOSECOND), Duration::ZERO);
128 assert_eq!(Duration::ZERO.saturating_sub(Duration::SECOND), Duration::ZERO);
1b1a35ee
XL		 129}
130
83c7162d
XL		 131#[test]
132#[should_panic]
133fn sub_bad1() {
134 let _ = Duration::new(0, 0) - Duration::new(0, 1);
135}
136
137#[test]
138#[should_panic]
139fn sub_bad2() {
140 let _ = Duration::new(0, 0) - Duration::new(1, 0);
141}
142
143#[test]
144fn mul() {
145 assert_eq!(Duration::new(0, 1) * 2, Duration::new(0, 2));
146 assert_eq!(Duration::new(1, 1) * 3, Duration::new(3, 3));
147 assert_eq!(Duration::new(0, 500_000_001) * 4, Duration::new(2, 4));
60c5eb7d 148 assert_eq!(Duration::new(0, 500_000_001) * 4000, Duration::new(2000, 4000));
83c7162d
XL		 149}
150
151#[test]
152fn checked_mul() {
153 assert_eq!(Duration::new(0, 1).checked_mul(2), Some(Duration::new(0, 2)));
154 assert_eq!(Duration::new(1, 1).checked_mul(3), Some(Duration::new(3, 3)));
155 assert_eq!(Duration::new(0, 500_000_001).checked_mul(4), Some(Duration::new(2, 4)));
60c5eb7d 156 assert_eq!(Duration::new(0, 500_000_001).checked_mul(4000), Some(Duration::new(2000, 4000)));
ba9703b0 157 assert_eq!(Duration::new(u64::MAX - 1, 0).checked_mul(2), None);
83c7162d
XL		 158}
159
1b1a35ee
XL		 160#[test]
161fn saturating_mul() {
162 assert_eq!(Duration::new(0, 1).saturating_mul(2), Duration::new(0, 2));
163 assert_eq!(Duration::new(1, 1).saturating_mul(3), Duration::new(3, 3));
164 assert_eq!(Duration::new(0, 500_000_001).saturating_mul(4), Duration::new(2, 4));
165 assert_eq!(Duration::new(0, 500_000_001).saturating_mul(4000), Duration::new(2000, 4000));
166 assert_eq!(Duration::new(u64::MAX - 1, 0).saturating_mul(2), Duration::MAX);
167}
168
83c7162d
XL		 169#[test]
170fn div() {
171 assert_eq!(Duration::new(0, 1) / 2, Duration::new(0, 0));
172 assert_eq!(Duration::new(1, 1) / 3, Duration::new(0, 333_333_333));
781aab86 173 assert_eq!(Duration::new(1, 1) / 7, Duration::new(0, 142_857_143));
60c5eb7d 174 assert_eq!(Duration::new(99, 999_999_000) / 100, Duration::new(0, 999_999_990));
83c7162d
XL		 175}
176
177#[test]
9c376795
FG		 178fn div_duration_f32() {
179 assert_eq!(Duration::ZERO.div_duration_f32(Duration::MAX), 0.0);
180 assert_eq!(Duration::MAX.div_duration_f32(Duration::ZERO), f32::INFINITY);
181 assert_eq!((Duration::SECOND * 2).div_duration_f32(Duration::SECOND), 2.0);
182 assert!(Duration::ZERO.div_duration_f32(Duration::ZERO).is_nan());
183 // These tests demonstrate it doesn't panic with extreme values.
184 // Accuracy of the computed value is not a huge concern, we know floats don't work well
185 // at these extremes.
186 assert!((Duration::MAX).div_duration_f32(Duration::NANOSECOND) > 10.0f32.powf(28.0));
187 assert!((Duration::NANOSECOND).div_duration_f32(Duration::MAX) < 0.1);
188}
189
190#[test]
191fn div_duration_f64() {
192 assert_eq!(Duration::ZERO.div_duration_f64(Duration::MAX), 0.0);
193 assert_eq!(Duration::MAX.div_duration_f64(Duration::ZERO), f64::INFINITY);
194 assert_eq!((Duration::SECOND * 2).div_duration_f64(Duration::SECOND), 2.0);
195 assert!(Duration::ZERO.div_duration_f64(Duration::ZERO).is_nan());
196 // These tests demonstrate it doesn't panic with extreme values.
197 // Accuracy of the computed value is not a huge concern, we know floats don't work well
198 // at these extremes.
199 assert!((Duration::MAX).div_duration_f64(Duration::NANOSECOND) > 10.0f64.powf(28.0));
200 assert!((Duration::NANOSECOND).div_duration_f64(Duration::MAX) < 0.1);
201}
202
203#[test]
83c7162d
XL		 204fn checked_div() {
205 assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));
206 assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));
207 assert_eq!(Duration::new(2, 0).checked_div(0), None);
208}
94b46f34 209
8faf50e0
XL		 210#[test]
211fn correct_sum() {
212 let durations = [
213 Duration::new(1, 999_999_999),
214 Duration::new(2, 999_999_999),
215 Duration::new(0, 999_999_999),
216 Duration::new(0, 999_999_999),
217 Duration::new(0, 999_999_999),
218 Duration::new(5, 0),
219 ];
220 let sum = durations.iter().sum::<Duration>();
60c5eb7d 221 assert_eq!(sum, Duration::new(1 + 2 + 5 + 4, 1_000_000_000 - 5));
8faf50e0
XL		 222}
223
94b46f34
XL		 224#[test]
225fn debug_formatting_extreme_values() {
226 assert_eq!(
2b03887a 227 format!("{:?}", Duration::new(u64::MAX, 123_456_789)),
94b46f34
XL		 228 "18446744073709551615.123456789s"
229 );
2b03887a
FG		 230 assert_eq!(format!("{:.0?}", Duration::MAX), "18446744073709551616s");
231 assert_eq!(format!("{:.0?}", Duration::new(u64::MAX, 500_000_000)), "18446744073709551616s");
232 assert_eq!(format!("{:.0?}", Duration::new(u64::MAX, 499_999_999)), "18446744073709551615s");
233 assert_eq!(
234 format!("{:.3?}", Duration::new(u64::MAX, 999_500_000)),
235 "18446744073709551616.000s"
236 );
237 assert_eq!(
238 format!("{:.3?}", Duration::new(u64::MAX, 999_499_999)),
239 "18446744073709551615.999s"
240 );
241 assert_eq!(
242 format!("{:.8?}", Duration::new(u64::MAX, 999_999_995)),
243 "18446744073709551616.00000000s"
244 );
245 assert_eq!(
246 format!("{:.8?}", Duration::new(u64::MAX, 999_999_994)),
247 "18446744073709551615.99999999s"
248 );
249 assert_eq!(format!("{:21.0?}", Duration::MAX), "18446744073709551616s");
250 assert_eq!(format!("{:22.0?}", Duration::MAX), "18446744073709551616s ");
251 assert_eq!(format!("{:24.0?}", Duration::MAX), "18446744073709551616s ");
94b46f34
XL		 252}
253
254#[test]
255fn debug_formatting_secs() {
256 assert_eq!(format!("{:?}", Duration::new(7, 000_000_000)), "7s");
257 assert_eq!(format!("{:?}", Duration::new(7, 100_000_000)), "7.1s");
258 assert_eq!(format!("{:?}", Duration::new(7, 000_010_000)), "7.00001s");
259 assert_eq!(format!("{:?}", Duration::new(7, 000_000_001)), "7.000000001s");
260 assert_eq!(format!("{:?}", Duration::new(7, 123_456_789)), "7.123456789s");
261
262 assert_eq!(format!("{:?}", Duration::new(88, 000_000_000)), "88s");
263 assert_eq!(format!("{:?}", Duration::new(88, 100_000_000)), "88.1s");
264 assert_eq!(format!("{:?}", Duration::new(88, 000_010_000)), "88.00001s");
265 assert_eq!(format!("{:?}", Duration::new(88, 000_000_001)), "88.000000001s");
266 assert_eq!(format!("{:?}", Duration::new(88, 123_456_789)), "88.123456789s");
267
268 assert_eq!(format!("{:?}", Duration::new(999, 000_000_000)), "999s");
269 assert_eq!(format!("{:?}", Duration::new(999, 100_000_000)), "999.1s");
270 assert_eq!(format!("{:?}", Duration::new(999, 000_010_000)), "999.00001s");
271 assert_eq!(format!("{:?}", Duration::new(999, 000_000_001)), "999.000000001s");
272 assert_eq!(format!("{:?}", Duration::new(999, 123_456_789)), "999.123456789s");
273}
274
275#[test]
276fn debug_formatting_millis() {
277 assert_eq!(format!("{:?}", Duration::new(0, 7_000_000)), "7ms");
278 assert_eq!(format!("{:?}", Duration::new(0, 7_100_000)), "7.1ms");
279 assert_eq!(format!("{:?}", Duration::new(0, 7_000_001)), "7.000001ms");
280 assert_eq!(format!("{:?}", Duration::new(0, 7_123_456)), "7.123456ms");
281
282 assert_eq!(format!("{:?}", Duration::new(0, 88_000_000)), "88ms");
283 assert_eq!(format!("{:?}", Duration::new(0, 88_100_000)), "88.1ms");
284 assert_eq!(format!("{:?}", Duration::new(0, 88_000_001)), "88.000001ms");
285 assert_eq!(format!("{:?}", Duration::new(0, 88_123_456)), "88.123456ms");
286
287 assert_eq!(format!("{:?}", Duration::new(0, 999_000_000)), "999ms");
288 assert_eq!(format!("{:?}", Duration::new(0, 999_100_000)), "999.1ms");
289 assert_eq!(format!("{:?}", Duration::new(0, 999_000_001)), "999.000001ms");
290 assert_eq!(format!("{:?}", Duration::new(0, 999_123_456)), "999.123456ms");
291}
292
293#[test]
294fn debug_formatting_micros() {
295 assert_eq!(format!("{:?}", Duration::new(0, 7_000)), "7µs");
296 assert_eq!(format!("{:?}", Duration::new(0, 7_100)), "7.1µs");
297 assert_eq!(format!("{:?}", Duration::new(0, 7_001)), "7.001µs");
298 assert_eq!(format!("{:?}", Duration::new(0, 7_123)), "7.123µs");
299
300 assert_eq!(format!("{:?}", Duration::new(0, 88_000)), "88µs");
301 assert_eq!(format!("{:?}", Duration::new(0, 88_100)), "88.1µs");
302 assert_eq!(format!("{:?}", Duration::new(0, 88_001)), "88.001µs");
303 assert_eq!(format!("{:?}", Duration::new(0, 88_123)), "88.123µs");
304
305 assert_eq!(format!("{:?}", Duration::new(0, 999_000)), "999µs");
306 assert_eq!(format!("{:?}", Duration::new(0, 999_100)), "999.1µs");
307 assert_eq!(format!("{:?}", Duration::new(0, 999_001)), "999.001µs");
308 assert_eq!(format!("{:?}", Duration::new(0, 999_123)), "999.123µs");
309}
310
311#[test]
312fn debug_formatting_nanos() {
313 assert_eq!(format!("{:?}", Duration::new(0, 0)), "0ns");
314 assert_eq!(format!("{:?}", Duration::new(0, 1)), "1ns");
315 assert_eq!(format!("{:?}", Duration::new(0, 88)), "88ns");
316 assert_eq!(format!("{:?}", Duration::new(0, 999)), "999ns");
317}
318
319#[test]
320fn debug_formatting_precision_zero() {
321 assert_eq!(format!("{:.0?}", Duration::new(0, 0)), "0ns");
322 assert_eq!(format!("{:.0?}", Duration::new(0, 123)), "123ns");
323
324 assert_eq!(format!("{:.0?}", Duration::new(0, 1_001)), "1µs");
325 assert_eq!(format!("{:.0?}", Duration::new(0, 1_499)), "1µs");
326 assert_eq!(format!("{:.0?}", Duration::new(0, 1_500)), "2µs");
327 assert_eq!(format!("{:.0?}", Duration::new(0, 1_999)), "2µs");
328
329 assert_eq!(format!("{:.0?}", Duration::new(0, 1_000_001)), "1ms");
330 assert_eq!(format!("{:.0?}", Duration::new(0, 1_499_999)), "1ms");
331 assert_eq!(format!("{:.0?}", Duration::new(0, 1_500_000)), "2ms");
332 assert_eq!(format!("{:.0?}", Duration::new(0, 1_999_999)), "2ms");
333
334 assert_eq!(format!("{:.0?}", Duration::new(1, 000_000_001)), "1s");
335 assert_eq!(format!("{:.0?}", Duration::new(1, 499_999_999)), "1s");
336 assert_eq!(format!("{:.0?}", Duration::new(1, 500_000_000)), "2s");
337 assert_eq!(format!("{:.0?}", Duration::new(1, 999_999_999)), "2s");
338}
339
340#[test]
341fn debug_formatting_precision_two() {
342 assert_eq!(format!("{:.2?}", Duration::new(0, 0)), "0.00ns");
343 assert_eq!(format!("{:.2?}", Duration::new(0, 123)), "123.00ns");
344
345 assert_eq!(format!("{:.2?}", Duration::new(0, 1_000)), "1.00µs");
346 assert_eq!(format!("{:.2?}", Duration::new(0, 7_001)), "7.00µs");
347 assert_eq!(format!("{:.2?}", Duration::new(0, 7_100)), "7.10µs");
348 assert_eq!(format!("{:.2?}", Duration::new(0, 7_109)), "7.11µs");
349 assert_eq!(format!("{:.2?}", Duration::new(0, 7_199)), "7.20µs");
350 assert_eq!(format!("{:.2?}", Duration::new(0, 1_999)), "2.00µs");
351
352 assert_eq!(format!("{:.2?}", Duration::new(0, 1_000_000)), "1.00ms");
353 assert_eq!(format!("{:.2?}", Duration::new(0, 3_001_000)), "3.00ms");
354 assert_eq!(format!("{:.2?}", Duration::new(0, 3_100_000)), "3.10ms");
355 assert_eq!(format!("{:.2?}", Duration::new(0, 1_999_999)), "2.00ms");
356
357 assert_eq!(format!("{:.2?}", Duration::new(1, 000_000_000)), "1.00s");
358 assert_eq!(format!("{:.2?}", Duration::new(4, 001_000_000)), "4.00s");
359 assert_eq!(format!("{:.2?}", Duration::new(2, 100_000_000)), "2.10s");
360 assert_eq!(format!("{:.2?}", Duration::new(2, 104_990_000)), "2.10s");
361 assert_eq!(format!("{:.2?}", Duration::new(2, 105_000_000)), "2.11s");
362 assert_eq!(format!("{:.2?}", Duration::new(8, 999_999_999)), "9.00s");
363}
364
c295e0f8
XL		 365#[test]
366fn debug_formatting_padding() {
367 assert_eq!("0ns ", format!("{:<9?}", Duration::new(0, 0)));
368 assert_eq!(" 0ns", format!("{:>9?}", Duration::new(0, 0)));
369 assert_eq!(" 0ns ", format!("{:^9?}", Duration::new(0, 0)));
370 assert_eq!("123ns ", format!("{:<9.0?}", Duration::new(0, 123)));
371 assert_eq!(" 123ns", format!("{:>9.0?}", Duration::new(0, 123)));
372 assert_eq!(" 123ns ", format!("{:^9.0?}", Duration::new(0, 123)));
373 assert_eq!("123.0ns ", format!("{:<9.1?}", Duration::new(0, 123)));
374 assert_eq!(" 123.0ns", format!("{:>9.1?}", Duration::new(0, 123)));
375 assert_eq!(" 123.0ns ", format!("{:^9.1?}", Duration::new(0, 123)));
376 assert_eq!("7.1µs ", format!("{:<9?}", Duration::new(0, 7_100)));
377 assert_eq!(" 7.1µs", format!("{:>9?}", Duration::new(0, 7_100)));
378 assert_eq!(" 7.1µs ", format!("{:^9?}", Duration::new(0, 7_100)));
379 assert_eq!("999.123456ms", format!("{:<9?}", Duration::new(0, 999_123_456)));
380 assert_eq!("999.123456ms", format!("{:>9?}", Duration::new(0, 999_123_456)));
381 assert_eq!("999.123456ms", format!("{:^9?}", Duration::new(0, 999_123_456)));
382 assert_eq!("5s ", format!("{:<9?}", Duration::new(5, 0)));
383 assert_eq!(" 5s", format!("{:>9?}", Duration::new(5, 0)));
384 assert_eq!(" 5s ", format!("{:^9?}", Duration::new(5, 0)));
385 assert_eq!("5.000000000000s", format!("{:<9.12?}", Duration::new(5, 0)));
386 assert_eq!("5.000000000000s", format!("{:>9.12?}", Duration::new(5, 0)));
387 assert_eq!("5.000000000000s", format!("{:^9.12?}", Duration::new(5, 0)));
388
389 // default alignment is left:
390 assert_eq!("5s ", format!("{:9?}", Duration::new(5, 0)));
391}
392
94b46f34
XL		 393#[test]
394fn debug_formatting_precision_high() {
60c5eb7d 395 assert_eq!(format!("{:.5?}", Duration::new(0, 23_678)), "23.67800µs");
94b46f34 396
60c5eb7d 397 assert_eq!(format!("{:.9?}", Duration::new(1, 000_000_000)), "1.000000000s");
94b46f34
XL		 398 assert_eq!(format!("{:.10?}", Duration::new(4, 001_000_000)), "4.0010000000s");
399 assert_eq!(format!("{:.20?}", Duration::new(4, 001_000_000)), "4.00100000000000000000s");
400}
1b1a35ee
XL		 401
402#[test]
403fn duration_const() {
404 // test that the methods of `Duration` are usable in a const context
405
406 const DURATION: Duration = Duration::new(0, 123_456_789);
407
408 const SUB_SEC_MILLIS: u32 = DURATION.subsec_millis();
409 assert_eq!(SUB_SEC_MILLIS, 123);
410
411 const SUB_SEC_MICROS: u32 = DURATION.subsec_micros();
412 assert_eq!(SUB_SEC_MICROS, 123_456);
413
414 const SUB_SEC_NANOS: u32 = DURATION.subsec_nanos();
415 assert_eq!(SUB_SEC_NANOS, 123_456_789);
416
29967ef6 417 const IS_ZERO: bool = Duration::ZERO.is_zero();
1b1a35ee
XL		 418 assert!(IS_ZERO);
419
29967ef6 420 const SECONDS: u64 = Duration::SECOND.as_secs();
1b1a35ee
XL		 421 assert_eq!(SECONDS, 1);
422
423 const FROM_SECONDS: Duration = Duration::from_secs(1);
29967ef6 424 assert_eq!(FROM_SECONDS, Duration::SECOND);
1b1a35ee 425
29967ef6 426 const SECONDS_F32: f32 = Duration::SECOND.as_secs_f32();
1b1a35ee
XL		 427 assert_eq!(SECONDS_F32, 1.0);
428
49aad941
FG		 429 // FIXME(#110395)
430 // const FROM_SECONDS_F32: Duration = Duration::from_secs_f32(1.0);
431 // assert_eq!(FROM_SECONDS_F32, Duration::SECOND);
1b1a35ee 432
29967ef6 433 const SECONDS_F64: f64 = Duration::SECOND.as_secs_f64();
1b1a35ee
XL		 434 assert_eq!(SECONDS_F64, 1.0);
435
49aad941
FG		 436 // FIXME(#110395)
437 // const FROM_SECONDS_F64: Duration = Duration::from_secs_f64(1.0);
438 // assert_eq!(FROM_SECONDS_F64, Duration::SECOND);
1b1a35ee 439
29967ef6 440 const MILLIS: u128 = Duration::SECOND.as_millis();
1b1a35ee
XL		 441 assert_eq!(MILLIS, 1_000);
442
443 const FROM_MILLIS: Duration = Duration::from_millis(1_000);
29967ef6 444 assert_eq!(FROM_MILLIS, Duration::SECOND);
1b1a35ee 445
29967ef6 446 const MICROS: u128 = Duration::SECOND.as_micros();
1b1a35ee
XL		 447 assert_eq!(MICROS, 1_000_000);
448
449 const FROM_MICROS: Duration = Duration::from_micros(1_000_000);
29967ef6 450 assert_eq!(FROM_MICROS, Duration::SECOND);
1b1a35ee 451
29967ef6 452 const NANOS: u128 = Duration::SECOND.as_nanos();
1b1a35ee
XL		 453 assert_eq!(NANOS, 1_000_000_000);
454
455 const FROM_NANOS: Duration = Duration::from_nanos(1_000_000_000);
29967ef6 456 assert_eq!(FROM_NANOS, Duration::SECOND);
1b1a35ee
XL		 457
458 const MAX: Duration = Duration::new(u64::MAX, 999_999_999);
459
29967ef6 460 const CHECKED_ADD: Option<Duration> = MAX.checked_add(Duration::SECOND);
1b1a35ee
XL		 461 assert_eq!(CHECKED_ADD, None);
462
29967ef6 463 const CHECKED_SUB: Option<Duration> = Duration::ZERO.checked_sub(Duration::SECOND);
1b1a35ee
XL		 464 assert_eq!(CHECKED_SUB, None);
465
29967ef6
XL		 466 const CHECKED_MUL: Option<Duration> = Duration::SECOND.checked_mul(1);
467 assert_eq!(CHECKED_MUL, Some(Duration::SECOND));
1b1a35ee 468
49aad941 469/* FIXME(#110395)
29967ef6
XL		 470 const MUL_F32: Duration = Duration::SECOND.mul_f32(1.0);
471 assert_eq!(MUL_F32, Duration::SECOND);
1b1a35ee 472
29967ef6
XL		 473 const MUL_F64: Duration = Duration::SECOND.mul_f64(1.0);
474 assert_eq!(MUL_F64, Duration::SECOND);
1b1a35ee 475
29967ef6
XL		 476 const CHECKED_DIV: Option<Duration> = Duration::SECOND.checked_div(1);
477 assert_eq!(CHECKED_DIV, Some(Duration::SECOND));
1b1a35ee 478
29967ef6
XL		 479 const DIV_F32: Duration = Duration::SECOND.div_f32(1.0);
480 assert_eq!(DIV_F32, Duration::SECOND);
1b1a35ee 481
29967ef6
XL		 482 const DIV_F64: Duration = Duration::SECOND.div_f64(1.0);
483 assert_eq!(DIV_F64, Duration::SECOND);
49aad941 484*/
1b1a35ee 485
29967ef6 486 const DIV_DURATION_F32: f32 = Duration::SECOND.div_duration_f32(Duration::SECOND);
1b1a35ee
XL		 487 assert_eq!(DIV_DURATION_F32, 1.0);
488
29967ef6 489 const DIV_DURATION_F64: f64 = Duration::SECOND.div_duration_f64(Duration::SECOND);
1b1a35ee
XL		 490 assert_eq!(DIV_DURATION_F64, 1.0);
491
29967ef6 492 const SATURATING_ADD: Duration = MAX.saturating_add(Duration::SECOND);
1b1a35ee
XL		 493 assert_eq!(SATURATING_ADD, MAX);
494
29967ef6
XL		 495 const SATURATING_SUB: Duration = Duration::ZERO.saturating_sub(Duration::SECOND);
496 assert_eq!(SATURATING_SUB, Duration::ZERO);
1b1a35ee
XL		 497
498 const SATURATING_MUL: Duration = MAX.saturating_mul(2);
499 assert_eq!(SATURATING_MUL, MAX);
500}
2b03887a
FG		 501
502#[test]
503fn from_neg_zero() {
504 assert_eq!(Duration::try_from_secs_f32(-0.0), Ok(Duration::ZERO));
505 assert_eq!(Duration::try_from_secs_f64(-0.0), Ok(Duration::ZERO));
506 assert_eq!(Duration::from_secs_f32(-0.0), Duration::ZERO);
507 assert_eq!(Duration::from_secs_f64(-0.0), Duration::ZERO);
508}
backport for Debian buster