1use ::time::*;
2use super::*;
3use nom::character::is_digit;
4
5named!(hour <u8>, map!(
6 take_while_m_n!(2, 2, is_digit),
7 buf_to_int
8));
9
10named!(minute <u8>, map!(
11 take_while_m_n!(2, 2, is_digit),
12 buf_to_int
13));
14
15named!(second <u8>, map!(
16 take_while_m_n!(2, 2, is_digit),
17 buf_to_int
18));
19
20named_args!(time_hms_format(extended: bool) <HmsTime>, do_parse!(
21 hour: hour >>
22 cond!(extended, char!(':')) >>
23 minute: minute >>
24 cond!(extended, char!(':')) >>
25 second: second >>
26 (HmsTime { hour, minute, second })
27));
28named!(time_hms_basic <HmsTime>, call!(time_hms_format, false));
29named!(time_hms_extended <HmsTime>, call!(time_hms_format, true));
30
31named!(pub time_hms <HmsTime>, alt!(
32 time_hms_extended |
33 time_hms_basic
34));
35
36named_args!(time_hm_format(extended: bool) <HmTime>, do_parse!(
37 hour: hour >>
38 cond!(extended, char!(':')) >>
39 minute: minute >>
40 (HmTime { hour, minute })
41));
42named!(time_hm_basic <HmTime>, call!(time_hm_format, false));
43named!(time_hm_extended <HmTime>, call!(time_hm_format, true));
44
45named!(pub time_hm <HmTime>, alt!(
46 time_hm_extended |
47 time_hm_basic
48));
49
50named!(pub time_h <HTime>, map!(hour, |hour| HTime { hour }));
51
52named!(time_naive_approx <ApproxNaiveTime>, alt!(
53 complete!(map!(time_hms, ApproxNaiveTime::HMS)) |
54 complete!(map!(time_hm, ApproxNaiveTime::HM)) |
55 complete!(map!(time_h, ApproxNaiveTime::H))
56));
57
58named!(pub time_local_approx <ApproxLocalTime>, do_parse!(
59 naive: time_naive_approx >>
60 fraction: opt!(complete!(frac32)) >>
61 (match naive {
62 ApproxNaiveTime::HMS(naive) => ApproxLocalTime::HMS(LocalTime {
63 naive,
64 fraction: fraction.unwrap_or(0.)
65 }),
66 ApproxNaiveTime::HM(naive) => ApproxLocalTime::HM(LocalTime {
67 naive,
68 fraction: fraction.unwrap_or(0.)
69 }),
70 ApproxNaiveTime::H(naive) => ApproxLocalTime::H(LocalTime {
71 naive,
72 fraction: fraction.unwrap_or(0.)
73 })
74 })
75));
76
77named!(pub time_global_approx <ApproxGlobalTime>, do_parse!(
78 local: time_local_approx >>
79 timezone: timezone >>
80 (match local {
81 ApproxLocalTime::HMS(local) => ApproxGlobalTime::HMS(GlobalTime { local, timezone }),
82 ApproxLocalTime::HM (local) => ApproxGlobalTime::HM (GlobalTime { local, timezone }),
83 ApproxLocalTime::H (local) => ApproxGlobalTime::H (GlobalTime { local, timezone })
84 })
85));
86
87named!(pub time_any_approx <ApproxAnyTime>, alt!(
88 map!(time_any_hms, ApproxAnyTime::HMS) |
89 map!(time_any_hm, ApproxAnyTime::HM) |
90 map!(time_any_h, ApproxAnyTime::H)
91));
92
93macro_rules! time_local_accuracy {
94 (pub $name:ident, $naive:ty, $naive_submac:ident) => {
95 named!(pub $name <LocalTime<$naive>>, do_parse!(
96 opt!(char!('T')) >>
97 naive: $naive_submac >>
98 fraction: opt!(complete!(frac32)) >>
99 (LocalTime {
100 naive,
101 fraction: fraction.unwrap_or(0.)
102 })
103 ));
104 }
105}
106time_local_accuracy!(pub time_local_hms, HmsTime, time_hms);
107time_local_accuracy!(pub time_local_hm, HmTime, time_hm);
108time_local_accuracy!(pub time_local_h, HTime, time_h);
109
110macro_rules! time_global_accuracy {
111 (pub $name:ident, $naive:ty, $local_submac:ident) => {
112 named!(pub $name <GlobalTime<$naive>>, do_parse!(
113 local: $local_submac >>
114 timezone: complete!(timezone) >>
115 (GlobalTime { local, timezone })
116 ));
117 }
118}
119time_global_accuracy!(pub time_global_hms, HmsTime, time_local_hms);
120time_global_accuracy!(pub time_global_hm, HmTime, time_local_hm);
121time_global_accuracy!(pub time_global_h, HTime, time_local_h);
122
123macro_rules! time_any_accuracy {
124 (pub $name:ident, $naive:ty, $local_submac:ident, $global_submac:ident) => {
125 named!(pub $name <AnyTime<$naive>>, alt!(
126 complete!(map!($global_submac, AnyTime::Global)) |
127 complete!(map!($local_submac, AnyTime::Local))
128 ));
129 }
130}
131time_any_accuracy!(pub time_any_hms, HmsTime, time_local_hms, time_global_hms);
132time_any_accuracy!(pub time_any_hm, HmTime, time_local_hm, time_global_hm);
133time_any_accuracy!(pub time_any_h, HTime, time_local_h, time_global_h);
134
135named!(timezone_utc <i16>, map!(char!('Z'), |_| 0));
136
137named!(timezone_fixed <i16>, do_parse!(
138 sign: sign >>
139 hour: hour >>
140 minute: opt!(complete!(do_parse!(
141 opt!(char!(':')) >>
142 minute: minute >>
143 (minute)
144 ))) >>
145 (sign as i16 * (hour as i16 * 60 + minute.unwrap_or(0) as i16))
146));
147
148named!(timezone <i16>, alt!(timezone_utc | timezone_fixed));
149
150#[cfg(test)]
151mod tests {
152 use super::*;
153 use nom::{
154 Err,
155 error::{
156 Error,
157 ErrorKind::Char
158 }
159 };
160
161 #[test]
162 fn hour() {
163 assert_eq!(super::hour(b"02"), Ok((&[][..], 2)));
164 assert_eq!(super::hour(b"24"), Ok((&[][..], 24)));
165 }
166
167 #[test]
168 fn minute() {
169 assert_eq!(super::minute(b"02"), Ok((&[][..], 2)));
170 assert_eq!(super::minute(b"59"), Ok((&[][..], 59)));
171 }
172
173 #[test]
174 fn second() {
175 assert_eq!(super::second(b"02 "), Ok((&b" "[..], 2)));
176 assert_eq!(super::second(b"02"), Ok((&[][..], 2)));
177 assert_eq!(super::second(b"60 "), Ok((&b" "[..], 60)));
178 assert_eq!(super::second(b"60"), Ok((&[][..], 60)));
179 }
180
181 #[test]
182 fn timezone_fixed() {
183 assert_eq!(super::timezone_fixed(b"+23:59 "), Ok((&b" "[..], 23 * 60 + 59)));
184 assert_eq!(super::timezone_fixed(b"+23:59"), Ok((&[][..], 23 * 60 + 59)));
185 assert_eq!(super::timezone_fixed(b"+2359 "), Ok((&b" "[..], 23 * 60 + 59)));
186 assert_eq!(super::timezone_fixed(b"+2359"), Ok((&[][..], 23 * 60 + 59)));
187 assert_eq!(super::timezone_fixed(b"-23 "), Ok((&b" "[..], -23 * 60)));
188 assert_eq!(super::timezone_fixed(b"-23"), Ok((&[][..], -23 * 60)));
189 }
190
191 #[test]
192 fn timezone_utc() {
193 assert_eq!(super::timezone_utc(b"Z "), Ok((&b" "[..], 0)));
194 assert_eq!(super::timezone_utc(b"Z"), Ok((&[][..], 0)));
195 assert_eq!(super::timezone_utc(b"z"), Err(Err::Error(Error { input: &b"z"[..], code: Char })));
196 }
197
198 #[test]
199 fn timezone() {
200 assert_eq!(super::timezone(b"-22:11 "), Ok((&b" "[..], -22 * 60 - 11)));
201 assert_eq!(super::timezone(b"-22:11"), Ok((&[][..], -22 * 60 - 11)));
202 assert_eq!(super::timezone(b"-2211 "), Ok((&b" "[..], -22 * 60 - 11)));
203 assert_eq!(super::timezone(b"-2211"), Ok((&[][..], -22 * 60 - 11)));
204 assert_eq!(super::timezone(b"Z "), Ok((&b" "[..], 0)));
205 assert_eq!(super::timezone(b"Z"), Ok((&[][..], 0)));
206 }
207
208 #[test]
209 fn time_hms() {
210 let value = HmsTime {
211 hour: 11,
212 minute: 22,
213 second: 33
214 };
215 assert_eq!(super::time_hms(b"11:22:33 "), Ok((&b" "[..], value.clone())));
216 assert_eq!(super::time_hms(b"11:22:33"), Ok((&[][..], value.clone())));
217 assert_eq!(super::time_hms(b"112233 "), Ok((&b" "[..], value.clone())));
218 assert_eq!(super::time_hms(b"112233"), Ok((&[][..], value)));
219 }
220
221 #[test]
222 fn time_hm() {
223 let value = HmTime {
224 hour: 11,
225 minute: 22
226 };
227 assert_eq!(super::time_hm(b"11:22 "), Ok((&b" "[..], value.clone())));
228 assert_eq!(super::time_hm(b"11:22"), Ok((&[][..], value.clone())));
229 assert_eq!(super::time_hm(b"1122 "), Ok((&b" "[..], value.clone())));
230 assert_eq!(super::time_hm(b"1122"), Ok((&[][..], value)));
231 }
232
233 #[test]
234 fn time_h() {
235 let value = HTime {
236 hour: 11
237 };
238 assert_eq!(super::time_h(b"11 "), Ok((&b" "[..], value.clone())));
239 assert_eq!(super::time_h(b"11"), Ok((&[][..], value)));
240 }
241
242 #[test]
243 fn time_local_hms() {
244 let value = LocalTime {
245 naive: HmsTime {
246 hour: 16,
247 minute: 43,
248 second: 52
249 },
250 fraction: 0.1
251 };
252 assert_eq!(super::time_local_hms(b"T16:43:52.1 "), Ok((&b" "[..], value.clone())));
253 assert_eq!(super::time_local_hms(b"T16:43:52.1"), Ok((&[][..], value.clone())));
254 assert_eq!(super::time_local_hms(b"16:43:52.1"), Ok((&[][..], value.clone())));
255 assert_eq!(super::time_local_hms(b"T164352.1"), Ok((&[][..], value.clone())));
256 assert_eq!(super::time_local_hms(b"164352.1"), Ok((&[][..], value.clone())));
257
258 let value = LocalTime {
259 fraction: 0.,
260 ..value
261 };
262 assert_eq!(super::time_local_hms(b"T16:43:52"), Ok((&[][..], value.clone())));
263 assert_eq!(super::time_local_hms(b"16:43:52"), Ok((&[][..], value)));
264 }
265
266 #[test]
267 fn time_local_hm() {
268 let value = LocalTime {
269 naive: HmTime {
270 hour: 16,
271 minute: 43
272 },
273 fraction: 0.1
274 };
275 assert_eq!(super::time_local_hm(b"T16:43.1"), Ok((&[][..], value.clone())));
276 assert_eq!(super::time_local_hm(b"16:43.1"), Ok((&[][..], value.clone())));
277 assert_eq!(super::time_local_hm(b"T1643.1"), Ok((&[][..], value.clone())));
278 assert_eq!(super::time_local_hm(b"1643.1"), Ok((&[][..], value.clone())));
279
280 let value = LocalTime {
281 fraction: 0.,
282 ..value
283 };
284 assert_eq!(super::time_local_hm(b"T16:43"), Ok((&[][..], value.clone())));
285 assert_eq!(super::time_local_hm(b"16:43"), Ok((&[][..], value.clone())));
286 assert_eq!(super::time_local_hm(b"T1643"), Ok((&[][..], value.clone())));
287 assert_eq!(super::time_local_hm(b"1643"), Ok((&[][..], value)));
288 }
289
290 #[test]
291 fn time_local_h() {
292 let value = LocalTime {
293 naive: HTime {
294 hour: 16
295 },
296 fraction: 0.1
297 };
298 assert_eq!(super::time_local_h(b"T16.1"), Ok((&[][..], value.clone())));
299 assert_eq!(super::time_local_h(b"16.1"), Ok((&[][..], value.clone())));
300
301 let value = LocalTime {
302 fraction: 0.,
303 ..value
304 };
305 assert_eq!(super::time_local_h(b"T16"), Ok((&[][..], value.clone())));
306 assert_eq!(super::time_local_h(b"16"), Ok((&[][..], value)));
307 }
308
309 #[test]
310 fn time_global_hms() {
311 let value = GlobalTime {
312 local: LocalTime {
313 naive: HmsTime {
314 hour: 16,
315 minute: 43,
316 second: 52
317 },
318 fraction: 0.
319 },
320 timezone: 0
321 };
322 assert_eq!(super::time_global_hms(b"T16:43:52Z"), Ok((&[][..], value.clone())));
323 assert_eq!(super::time_global_hms(b"16:43:52Z"), Ok((&[][..], value.clone())));
324 assert_eq!(super::time_global_hms(b"T164352Z"), Ok((&[][..], value.clone())));
325 assert_eq!(super::time_global_hms(b"164352Z"), Ok((&[][..], value.clone())));
326
327 {
328 let value = GlobalTime {
329 timezone: 2,
330 ..value.clone()
331 };
332 assert_eq!(super::time_global_hms(b"T16:43:52+0002"), Ok((&[][..], value.clone())));
333 assert_eq!(super::time_global_hms(b"16:43:52+0002"), Ok((&[][..], value.clone())));
334 assert_eq!(super::time_global_hms(b"T164352+0002"), Ok((&[][..], value.clone())));
335 assert_eq!(super::time_global_hms(b"164352+0002"), Ok((&[][..], value.clone())));
336
337 let value = GlobalTime {
338 local: LocalTime {
339 fraction: 0.1,
340 ..value.local
341 },
342 ..value
343 };
344 assert_eq!(super::time_global_hms(b"T16:43:52.1+0002"), Ok((&[][..], value.clone())));
345 assert_eq!(super::time_global_hms(b"16:43:52.1+0002"), Ok((&[][..], value.clone())));
346 assert_eq!(super::time_global_hms(b"T164352.1+0002"), Ok((&[][..], value.clone())));
347 assert_eq!(super::time_global_hms(b"164352.1+0002"), Ok((&[][..], value)));
348 }
349
350 let value = GlobalTime {
351 local: LocalTime {
352 fraction: 0.1,
353 ..value.local
354 },
355 ..value
356 };
357 assert_eq!(super::time_global_hms(b"T16:43:52.1Z"), Ok((&[][..], value.clone())));
358 assert_eq!(super::time_global_hms(b"16:43:52.1Z"), Ok((&[][..], value.clone())));
359 assert_eq!(super::time_global_hms(b"T164352.1Z"), Ok((&[][..], value.clone())));
360 assert_eq!(super::time_global_hms(b"164352.1Z"), Ok((&[][..], value)));
361 }
362
363 #[test]
364 fn time_global_hm() {
365 let value = GlobalTime {
366 local: LocalTime {
367 naive: HmTime {
368 hour: 16,
369 minute: 43
370 },
371 fraction: 0.
372 },
373 timezone: 0
374 };
375 assert_eq!(super::time_global_hm(b"T16:43Z"), Ok((&[][..], value.clone())));
376 assert_eq!(super::time_global_hm(b"16:43Z"), Ok((&[][..], value.clone())));
377 assert_eq!(super::time_global_hm(b"T1643Z"), Ok((&[][..], value.clone())));
378 assert_eq!(super::time_global_hm(b"1643Z"), Ok((&[][..], value.clone())));
379
380 let value = GlobalTime {
381 local: LocalTime {
382 fraction: 0.1,
383 ..value.local
384 },
385 ..value
386 };
387 assert_eq!(super::time_global_hm(b"T16:43.1Z"), Ok((&[][..], value.clone())));
388 assert_eq!(super::time_global_hm(b"16:43.1Z"), Ok((&[][..], value.clone())));
389 assert_eq!(super::time_global_hm(b"T1643.1Z"), Ok((&[][..], value.clone())));
390 assert_eq!(super::time_global_hm(b"1643.1Z"), Ok((&[][..], value)));
391 }
392
393 #[test]
394 fn time_global_h() {
395 let value = GlobalTime {
396 local: LocalTime {
397 naive: HTime {
398 hour: 16
399 },
400 fraction: 0.
401 },
402 timezone: 0
403 };
404 assert_eq!(super::time_global_h(b"T16Z"), Ok((&[][..], value.clone())));
405 assert_eq!(super::time_global_h(b"16Z"), Ok((&[][..], value.clone())));
406
407 let value = GlobalTime {
408 local: LocalTime {
409 fraction: 0.1,
410 ..value.local
411 },
412 ..value
413 };
414 assert_eq!(super::time_global_h(b"T16.1Z"), Ok((&[][..], value.clone())));
415 assert_eq!(super::time_global_h(b"16.1Z"), Ok((&[][..], value)));
416 }
417
418 #[test]
419 fn time_any_hms() {
420 let value = AnyTime::Local(LocalTime {
421 naive: HmsTime {
422 hour: 16,
423 minute: 43,
424 second: 52
425 },
426 fraction: 0.
427 });
428 assert_eq!(super::time_any_hms(b"T16:43:52"), Ok((&[][..], value.clone())));
429 assert_eq!(super::time_any_hms(b"16:43:52"), Ok((&[][..], value.clone())));
430 assert_eq!(super::time_any_hms(b"T164352"), Ok((&[][..], value.clone())));
431 assert_eq!(super::time_any_hms(b"164352"), Ok((&[][..], value)));
432
433 let value = AnyTime::Global(GlobalTime {
434 local: LocalTime {
435 naive: HmsTime {
436 hour: 2,
437 minute: 3,
438 second: 52
439 },
440 fraction: 0.
441 },
442 timezone: 0
443 });
444 assert_eq!(super::time_any_hms(b"T02:03:52Z"), Ok((&[][..], value.clone())));
445 assert_eq!(super::time_any_hms(b"02:03:52Z"), Ok((&[][..], value.clone())));
446 assert_eq!(super::time_any_hms(b"T020352Z"), Ok((&[][..], value.clone())));
447 assert_eq!(super::time_any_hms(b"020352Z"), Ok((&[][..], value)));
448
449 let value = AnyTime::Global(GlobalTime {
450 local: LocalTime {
451 naive: HmsTime {
452 hour: 2,
453 minute: 3,
454 second: 52
455 },
456 fraction: 0.
457 },
458 timezone: -1 * 60
459 });
460 assert_eq!(super::time_any_hms(b"T02:03:52-01"), Ok((&[][..], value.clone())));
461 assert_eq!(super::time_any_hms(b"02:03:52-01"), Ok((&[][..], value.clone())));
462 assert_eq!(super::time_any_hms(b"T020352-01"), Ok((&[][..], value.clone())));
463 assert_eq!(super::time_any_hms(b"020352-01"), Ok((&[][..], value)));
464 }
465
466 #[test]
467 fn time_any_hm() {
468 let value = AnyTime::Local(LocalTime {
469 naive: HmTime {
470 hour: 16,
471 minute: 43
472 },
473 fraction: 0.
474 });
475 assert_eq!(super::time_any_hm(b"T16:43"), Ok((&[][..], value.clone())));
476 assert_eq!(super::time_any_hm(b"16:43"), Ok((&[][..], value.clone())));
477 assert_eq!(super::time_any_hm(b"T1643"), Ok((&[][..], value.clone())));
478 assert_eq!(super::time_any_hm(b"1643"), Ok((&[][..], value)));
479
480 let value = AnyTime::Global(GlobalTime {
481 local: LocalTime {
482 naive: HmTime {
483 hour: 2,
484 minute: 3
485 },
486 fraction: 0.
487 },
488 timezone: 0
489 });
490 assert_eq!(super::time_any_hm(b"T02:03Z"), Ok((&[][..], value.clone())));
491 assert_eq!(super::time_any_hm(b"02:03Z"), Ok((&[][..], value.clone())));
492 assert_eq!(super::time_any_hm(b"T0203Z"), Ok((&[][..], value.clone())));
493 assert_eq!(super::time_any_hm(b"0203Z"), Ok((&[][..], value)));
494
495 let value = AnyTime::Global(GlobalTime {
496 local: LocalTime {
497 naive: HmTime {
498 hour: 2,
499 minute: 3
500 },
501 fraction: 0.
502 },
503 timezone: -1 * 60
504 });
505 assert_eq!(super::time_any_hm(b"T02:03-01"), Ok((&[][..], value.clone())));
506 assert_eq!(super::time_any_hm(b"02:03-01"), Ok((&[][..], value.clone())));
507 assert_eq!(super::time_any_hm(b"T0203-01"), Ok((&[][..], value.clone())));
508 assert_eq!(super::time_any_hm(b"0203-01"), Ok((&[][..], value)));
509 }
510
511 #[test]
512 fn time_any_h() {
513 let value = AnyTime::Local(LocalTime {
514 naive: HTime {
515 hour: 16
516 },
517 fraction: 0.
518 });
519 assert_eq!(super::time_any_h(b"T16"), Ok((&[][..], value.clone())));
520 assert_eq!(super::time_any_h(b"16"), Ok((&[][..], value)));
521
522 let value = AnyTime::Global(GlobalTime {
523 local: LocalTime {
524 naive: HTime {
525 hour: 2
526 },
527 fraction: 0.
528 },
529 timezone: 0
530 });
531 assert_eq!(super::time_any_h(b"T02Z"), Ok((&[][..], value.clone())));
532 assert_eq!(super::time_any_h(b"02Z"), Ok((&[][..], value)));
533
534 let value = AnyTime::Global(GlobalTime {
535 local: LocalTime {
536 naive: HTime {
537 hour: 2
538 },
539 fraction: 0.
540 },
541 timezone: -1 * 60
542 });
543 assert_eq!(super::time_any_h(b"T02-01"), Ok((&[][..], value.clone())));
544 assert_eq!(super::time_any_h(b"02-01"), Ok((&[][..], value)));
545 }
546
547 #[test]
548 fn time_local_approx() {
549 assert_eq!(super::time_local_approx(b"16:22:48"), Ok((&[][..], ApproxLocalTime::HMS(LocalTime {
550 naive: HmsTime {
551 hour: 16,
552 minute: 22,
553 second: 48
554 },
555 fraction: 0.
556 }))));
557
558 assert_eq!(super::time_local_approx(b"16:22"), Ok((&[][..], ApproxLocalTime::HM(LocalTime {
559 naive: HmTime {
560 hour: 16,
561 minute: 22
562 },
563 fraction: 0.
564 }))));
565
566 assert_eq!(super::time_local_approx(b"16"), Ok((&[][..], ApproxLocalTime::H(LocalTime {
567 naive: HTime {
568 hour: 16
569 },
570 fraction: 0.
571 }))));
572 }
573
574 #[test]
575 fn time_global_approx() {
576 assert_eq!(super::time_global_approx(b"16:22:48Z"), Ok((&[][..], ApproxGlobalTime::HMS(GlobalTime {
577 local: LocalTime {
578 naive: HmsTime {
579 hour: 16,
580 minute: 22,
581 second: 48
582 },
583 fraction: 0.
584 },
585 timezone: 0
586 }))));
587
588 assert_eq!(super::time_global_approx(b"16:22Z"), Ok((&[][..], ApproxGlobalTime::HM(GlobalTime {
589 local: LocalTime {
590 naive: HmTime {
591 hour: 16,
592 minute: 22
593 },
594 fraction: 0.
595 },
596 timezone: 0
597 }))));
598
599 assert_eq!(super::time_global_approx(b"16Z"), Ok((&[][..], ApproxGlobalTime::H(GlobalTime {
600 local: LocalTime {
601 naive: HTime {
602 hour: 16
603 },
604 fraction: 0.
605 },
606 timezone: 0
607 }))));
608 }
609
610 #[test]
611 fn time_any_approx() {
612 assert_eq!(super::time_any_approx(b"16:22:48"), Ok((&[][..], ApproxAnyTime::HMS(AnyTime::Local(LocalTime {
613 naive: HmsTime {
614 hour: 16,
615 minute: 22,
616 second: 48
617 },
618 fraction: 0.
619 })))));
620 assert_eq!(super::time_any_approx(b"16:22"), Ok((&[][..], ApproxAnyTime::HM(AnyTime::Local(LocalTime {
621 naive: HmTime {
622 hour: 16,
623 minute: 22
624 },
625 fraction: 0.
626 })))));
627 assert_eq!(super::time_any_approx(b"16"), Ok((&[][..], ApproxAnyTime::H(AnyTime::Local(LocalTime {
628 naive: HTime {
629 hour: 16
630 },
631 fraction: 0.
632 })))));
633
634 assert_eq!(super::time_any_approx(b"16:22:48Z"), Ok((&[][..], ApproxAnyTime::HMS(AnyTime::Global(GlobalTime {
635 local: LocalTime {
636 naive: HmsTime {
637 hour: 16,
638 minute: 22,
639 second: 48
640 },
641 fraction: 0.
642 },
643 timezone: 0
644 })))));
645 assert_eq!(super::time_any_approx(b"16:22Z"), Ok((&[][..], ApproxAnyTime::HM(AnyTime::Global(GlobalTime {
646 local: LocalTime {
647 naive: HmTime {
648 hour: 16,
649 minute: 22
650 },
651 fraction: 0.
652 },
653 timezone: 0
654 })))));
655 assert_eq!(super::time_any_approx(b"16Z"), Ok((&[][..], ApproxAnyTime::H(AnyTime::Global(GlobalTime {
656 local: LocalTime {
657 naive: HTime {
658 hour: 16
659 },
660 fraction: 0.
661 },
662 timezone: 0
663 })))));
664 }
665}