1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 #[crate_id = "time#0.10-pre"];
12 #[crate_type = "rlib"];
13 #[crate_type = "dylib"];
14 #[license = "MIT/ASL2"];
15 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
16 html_favicon_url = "http://www.rust-lang.org/favicon.ico",
17 html_root_url = "http://static.rust-lang.org/doc/master")];
20 #[allow(deprecated_owned_vector)];
22 #[cfg(test)] #[phase(syntax, link)] extern crate log;
23 extern crate serialize;
25 use std::io::BufReader;
30 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
37 pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
38 pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
39 pub fn rust_timegm(tm: &Tm) -> i64;
40 pub fn rust_mktime(tm: &Tm) -> i64;
44 #[cfg(unix, not(target_os = "macos"))]
46 use std::libc::{c_int, timespec};
48 // Apparently android provides this in some other library?
49 #[cfg(not(target_os = "android"))]
54 pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int;
58 #[cfg(target_os = "macos")]
60 use std::libc::{timeval, timezone, c_int, mach_timebase_info};
63 pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int;
64 pub fn mach_absolute_time() -> u64;
65 pub fn mach_timebase_info(info: *mut mach_timebase_info) -> c_int;
69 /// A record specifying a time value in seconds and nanoseconds.
70 #[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Encodable, Decodable, Show)]
71 pub struct Timespec { sec: i64, nsec: i32 }
73 * Timespec assumes that pre-epoch Timespecs have negative sec and positive
74 * nsec fields. Darwin's and Linux's struct timespec functions handle pre-
75 * epoch timestamps using a "two steps back, one step forward" representation,
76 * though the man pages do not actually document this. For example, the time
77 * -1.2 seconds before the epoch is represented by `Timespec { sec: -2_i64,
78 * nsec: 800_000_000_i32 }`.
81 pub fn new(sec: i64, nsec: i32) -> Timespec {
82 assert!(nsec >= 0 && nsec < NSEC_PER_SEC);
83 Timespec { sec: sec, nsec: nsec }
88 * Returns the current time as a `timespec` containing the seconds and
89 * nanoseconds since 1970-01-01T00:00:00Z.
91 pub fn get_time() -> Timespec {
93 let (sec, nsec) = os_get_time();
94 return Timespec::new(sec, nsec);
98 unsafe fn os_get_time() -> (i64, i32) {
99 static NANOSECONDS_FROM_1601_TO_1970: u64 = 11644473600000000;
101 let mut time = libc::FILETIME {
105 libc::GetSystemTimeAsFileTime(&mut time);
107 // A FILETIME contains a 64-bit value representing the number of
108 // hectonanosecond (100-nanosecond) intervals since 1601-01-01T00:00:00Z.
109 // http://support.microsoft.com/kb/167296/en-us
110 let ns_since_1601 = ((time.dwHighDateTime as u64 << 32) |
111 (time.dwLowDateTime as u64 << 0)) / 10;
112 let ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
114 ((ns_since_1970 / 1000000) as i64,
115 ((ns_since_1970 % 1000000) * 1000) as i32)
118 #[cfg(target_os = "macos")]
119 unsafe fn os_get_time() -> (i64, i32) {
121 let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 };
122 imp::gettimeofday(&mut tv, ptr::mut_null());
123 (tv.tv_sec as i64, tv.tv_usec * 1000)
126 #[cfg(not(target_os = "macos"), not(windows))]
127 unsafe fn os_get_time() -> (i64, i32) {
128 let mut tv = libc::timespec { tv_sec: 0, tv_nsec: 0 };
129 imp::clock_gettime(libc::CLOCK_REALTIME, &mut tv);
130 (tv.tv_sec as i64, tv.tv_nsec as i32)
136 * Returns the current value of a high-resolution performance counter
137 * in nanoseconds since an unspecified epoch.
139 pub fn precise_time_ns() -> u64 {
140 return os_precise_time_ns();
143 fn os_precise_time_ns() -> u64 {
144 let mut ticks_per_s = 0;
146 libc::QueryPerformanceFrequency(&mut ticks_per_s)
148 let ticks_per_s = if ticks_per_s == 0 {1} else {ticks_per_s};
151 libc::QueryPerformanceCounter(&mut ticks)
154 return (ticks as u64 * 1000000000) / (ticks_per_s as u64);
157 #[cfg(target_os = "macos")]
158 fn os_precise_time_ns() -> u64 {
159 let time = unsafe { imp::mach_absolute_time() };
160 let mut info = libc::mach_timebase_info { numer: 0, denom: 0 };
161 unsafe { imp::mach_timebase_info(&mut info); }
162 return time * ((info.numer / info.denom) as u64);
165 #[cfg(not(windows), not(target_os = "macos"))]
166 fn os_precise_time_ns() -> u64 {
167 let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 };
169 imp::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts);
171 return (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64)
177 * Returns the current value of a high-resolution performance counter
178 * in seconds since an unspecified epoch.
180 pub fn precise_time_s() -> f64 {
181 return (precise_time_ns() as f64) / 1000000000.;
186 rustrt::rust_tzset();
190 /// Holds a calendar date and time broken down into its components (year, month, day, and so on),
191 /// also called a broken-down time value.
192 #[deriving(Clone, Eq, Encodable, Decodable, Show)]
194 /// Seconds after the minute – [0, 60]
197 /// Minutes after the hour – [0, 59]
200 /// Hours after midnight – [0, 23]
203 /// Day of the month – [1, 31]
206 /// Months since January – [0, 11]
212 /// Days since Sunday – [0, 6]. 0 = Sunday, 1 = Monday, …, 6 = Saturday.
215 /// Days since January 1 – [0, 365]
218 /// Daylight Saving Time flag.
220 /// This value is positive if Daylight Saving Time is in effect, zero if Daylight Saving Time
221 /// is not in effect, and negative if this information is not available.
224 /// Identifies the time zone that was used to compute this broken-down time value, including any
225 /// adjustment for Daylight Saving Time. This is the number of seconds east of UTC. For example,
226 /// for U.S. Pacific Daylight Time, the value is -7*60*60 = -25200.
229 /// Abbreviated name for the time zone that was used to compute this broken-down time value.
230 /// For example, U.S. Pacific Daylight Time is "PDT".
233 /// Nanoseconds after the second – [0, 10<sup>9</sup> - 1]
237 pub fn empty_tm() -> Tm {
238 // 64 is the max size of the timezone buffer allocated on windows
239 // in rust_localtime. In glibc the max timezone size is supposedly 3.
240 let zone = str::with_capacity(64);
257 /// Returns the specified time in UTC
258 pub fn at_utc(clock: Timespec) -> Tm {
260 let Timespec { sec, nsec } = clock;
261 let mut tm = empty_tm();
262 rustrt::rust_gmtime(sec, nsec, &mut tm);
267 /// Returns the current time in UTC
268 pub fn now_utc() -> Tm {
272 /// Returns the specified time in the local timezone
273 pub fn at(clock: Timespec) -> Tm {
275 let Timespec { sec, nsec } = clock;
276 let mut tm = empty_tm();
277 rustrt::rust_localtime(sec, nsec, &mut tm);
282 /// Returns the current time in the local timezone
289 /// Convert time to the seconds from January 1, 1970
290 pub fn to_timespec(&self) -> Timespec {
292 let sec = match self.tm_gmtoff {
293 0_i32 => rustrt::rust_timegm(self),
294 _ => rustrt::rust_mktime(self)
297 Timespec::new(sec, self.tm_nsec)
301 /// Convert time to the local timezone
302 pub fn to_local(&self) -> Tm {
303 at(self.to_timespec())
306 /// Convert time to the UTC
307 pub fn to_utc(&self) -> Tm {
308 at_utc(self.to_timespec())
312 * Return a string of the current time in the form
313 * "Thu Jan 1 00:00:00 1970".
315 pub fn ctime(&self) -> ~str { self.strftime("%c") }
317 /// Formats the time according to the format string.
318 pub fn strftime(&self, format: &str) -> ~str {
319 strftime(format, self)
323 * Returns a time string formatted according to RFC 822.
325 * local: "Thu, 22 Mar 2012 07:53:18 PST"
326 * utc: "Thu, 22 Mar 2012 14:53:18 UTC"
328 pub fn rfc822(&self) -> ~str {
329 if self.tm_gmtoff == 0_i32 {
330 self.strftime("%a, %d %b %Y %T GMT")
332 self.strftime("%a, %d %b %Y %T %Z")
337 * Returns a time string formatted according to RFC 822 with Zulu time.
339 * local: "Thu, 22 Mar 2012 07:53:18 -0700"
340 * utc: "Thu, 22 Mar 2012 14:53:18 -0000"
342 pub fn rfc822z(&self) -> ~str {
343 self.strftime("%a, %d %b %Y %T %z")
347 * Returns a time string formatted according to ISO 8601.
349 * local: "2012-02-22T07:53:18-07:00"
350 * utc: "2012-02-22T14:53:18Z"
352 pub fn rfc3339(&self) -> ~str {
353 if self.tm_gmtoff == 0_i32 {
354 self.strftime("%Y-%m-%dT%H:%M:%SZ")
356 let s = self.strftime("%Y-%m-%dT%H:%M:%S");
357 let sign = if self.tm_gmtoff > 0_i32 { '+' } else { '-' };
358 let mut m = num::abs(self.tm_gmtoff) / 60_i32;
361 s + format!("{}{:02d}:{:02d}", sign, h as int, m as int)
366 /// Parses the time from the string according to the format string.
367 pub fn strptime(s: &str, format: &str) -> Result<Tm, ~str> {
368 fn match_str(s: &str, pos: uint, needle: &str) -> bool {
370 for ch in needle.bytes() {
379 fn match_strs(ss: &str, pos: uint, strs: &[(~str, i32)])
380 -> Option<(i32, uint)> {
382 let len = strs.len();
384 match strs[i] { // can't use let due to let-pattern bugs
385 (ref needle, value) => {
386 if match_str(ss, pos, *needle) {
387 return Some((value, pos + needle.len()));
397 fn match_digits(ss: &str, pos: uint, digits: uint, ws: bool)
398 -> Option<(i32, uint)> {
401 let mut value = 0_i32;
408 let range = ss.char_range_at(pos);
413 value = value * 10_i32 + (range.ch as i32 - '0' as i32);
424 fn match_fractional_seconds(ss: &str, pos: uint) -> (i32, uint) {
426 let mut value = 0_i32;
427 let mut multiplier = NSEC_PER_SEC / 10;
434 let range = ss.char_range_at(pos);
439 // This will drop digits after the nanoseconds place
440 let digit = range.ch as i32 - '0' as i32;
441 value += digit * multiplier;
451 fn match_digits_in_range(ss: &str, pos: uint, digits: uint, ws: bool,
452 min: i32, max: i32) -> Option<(i32, uint)> {
453 match match_digits(ss, pos, digits, ws) {
454 Some((val, pos)) if val >= min && val <= max => {
461 fn parse_char(s: &str, pos: uint, c: char) -> Result<uint, ~str> {
462 let range = s.char_range_at(pos);
467 Err(format!("Expected {}, found {}",
469 str::from_char(range.ch)))
473 fn parse_type(s: &str, pos: uint, ch: char, tm: &mut Tm)
474 -> Result<uint, ~str> {
476 'A' => match match_strs(s, pos, [
480 (~"Wednesday", 3_i32),
481 (~"Thursday", 4_i32),
485 Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
486 None => Err(~"Invalid day")
488 'a' => match match_strs(s, pos, [
497 Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
498 None => Err(~"Invalid day")
500 'B' => match match_strs(s, pos, [
502 (~"February", 1_i32),
509 (~"September", 8_i32),
511 (~"November", 10_i32),
512 (~"December", 11_i32)
514 Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
515 None => Err(~"Invalid month")
517 'b' | 'h' => match match_strs(s, pos, [
531 Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
532 None => Err(~"Invalid month")
534 'C' => match match_digits_in_range(s, pos, 2u, false, 0_i32,
538 tm.tm_year += (v * 100_i32) - 1900_i32;
541 None => Err(~"Invalid year")
544 parse_type(s, pos, 'a', &mut *tm)
545 .and_then(|pos| parse_char(s, pos, ' '))
546 .and_then(|pos| parse_type(s, pos, 'b', &mut *tm))
547 .and_then(|pos| parse_char(s, pos, ' '))
548 .and_then(|pos| parse_type(s, pos, 'e', &mut *tm))
549 .and_then(|pos| parse_char(s, pos, ' '))
550 .and_then(|pos| parse_type(s, pos, 'T', &mut *tm))
551 .and_then(|pos| parse_char(s, pos, ' '))
552 .and_then(|pos| parse_type(s, pos, 'Y', &mut *tm))
555 parse_type(s, pos, 'm', &mut *tm)
556 .and_then(|pos| parse_char(s, pos, '/'))
557 .and_then(|pos| parse_type(s, pos, 'd', &mut *tm))
558 .and_then(|pos| parse_char(s, pos, '/'))
559 .and_then(|pos| parse_type(s, pos, 'y', &mut *tm))
561 'd' => match match_digits_in_range(s, pos, 2u, false, 1_i32,
563 Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
564 None => Err(~"Invalid day of the month")
566 'e' => match match_digits_in_range(s, pos, 2u, true, 1_i32,
568 Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
569 None => Err(~"Invalid day of the month")
572 let (val, pos) = match_fractional_seconds(s, pos);
577 parse_type(s, pos, 'Y', &mut *tm)
578 .and_then(|pos| parse_char(s, pos, '-'))
579 .and_then(|pos| parse_type(s, pos, 'm', &mut *tm))
580 .and_then(|pos| parse_char(s, pos, '-'))
581 .and_then(|pos| parse_type(s, pos, 'd', &mut *tm))
584 match match_digits_in_range(s, pos, 2u, false, 0_i32, 23_i32) {
585 Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) }
586 None => Err(~"Invalid hour")
590 match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) {
593 tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
596 None => Err(~"Invalid hour")
600 match match_digits_in_range(s, pos, 3u, false, 1_i32, 366_i32) {
603 tm.tm_yday = v - 1_i32;
606 None => Err(~"Invalid day of year")
610 match match_digits_in_range(s, pos, 2u, true, 0_i32, 23_i32) {
611 Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) }
612 None => Err(~"Invalid hour")
616 match match_digits_in_range(s, pos, 2u, true, 1_i32, 12_i32) {
619 tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
622 None => Err(~"Invalid hour")
626 match match_digits_in_range(s, pos, 2u, false, 0_i32, 59_i32) {
627 Some(item) => { let (v, pos) = item; tm.tm_min = v; Ok(pos) }
628 None => Err(~"Invalid minute")
632 match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) {
635 tm.tm_mon = v - 1_i32;
638 None => Err(~"Invalid month")
641 'n' => parse_char(s, pos, '\n'),
642 'P' => match match_strs(s, pos,
643 [(~"am", 0_i32), (~"pm", 12_i32)]) {
645 Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
646 None => Err(~"Invalid hour")
648 'p' => match match_strs(s, pos,
649 [(~"AM", 0_i32), (~"PM", 12_i32)]) {
651 Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
652 None => Err(~"Invalid hour")
655 parse_type(s, pos, 'H', &mut *tm)
656 .and_then(|pos| parse_char(s, pos, ':'))
657 .and_then(|pos| parse_type(s, pos, 'M', &mut *tm))
660 parse_type(s, pos, 'I', &mut *tm)
661 .and_then(|pos| parse_char(s, pos, ':'))
662 .and_then(|pos| parse_type(s, pos, 'M', &mut *tm))
663 .and_then(|pos| parse_char(s, pos, ':'))
664 .and_then(|pos| parse_type(s, pos, 'S', &mut *tm))
665 .and_then(|pos| parse_char(s, pos, ' '))
666 .and_then(|pos| parse_type(s, pos, 'p', &mut *tm))
669 match match_digits_in_range(s, pos, 2u, false, 0_i32, 60_i32) {
675 None => Err(~"Invalid second")
680 parse_type(s, pos, 'H', &mut *tm)
681 .and_then(|pos| parse_char(s, pos, ':'))
682 .and_then(|pos| parse_type(s, pos, 'M', &mut *tm))
683 .and_then(|pos| parse_char(s, pos, ':'))
684 .and_then(|pos| parse_type(s, pos, 'S', &mut *tm))
686 't' => parse_char(s, pos, '\t'),
688 match match_digits_in_range(s, pos, 1u, false, 1_i32, 7_i32) {
691 tm.tm_wday = if v == 7 { 0 } else { v };
694 None => Err(~"Invalid day of week")
698 parse_type(s, pos, 'e', &mut *tm)
699 .and_then(|pos| parse_char(s, pos, '-'))
700 .and_then(|pos| parse_type(s, pos, 'b', &mut *tm))
701 .and_then(|pos| parse_char(s, pos, '-'))
702 .and_then(|pos| parse_type(s, pos, 'Y', &mut *tm))
706 match match_digits_in_range(s, pos, 1u, false, 0_i32, 6_i32) {
707 Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
708 None => Err(~"Invalid day of week")
712 match match_digits(s, pos, 4u, false) {
715 tm.tm_year = v - 1900_i32;
718 None => Err(~"Invalid year")
722 match match_digits_in_range(s, pos, 2u, false, 0_i32, 99_i32) {
728 None => Err(~"Invalid year")
732 if match_str(s, pos, "UTC") || match_str(s, pos, "GMT") {
733 tm.tm_gmtoff = 0_i32;
737 // It's odd, but to maintain compatibility with c's
738 // strptime we ignore the timezone.
742 let range = s.char_range_at(pos);
744 if range.ch == ' ' { break; }
751 let range = s.char_range_at(pos);
753 if range.ch == '+' || range.ch == '-' {
754 match match_digits(s, range.next, 4u, false) {
758 tm.tm_gmtoff = 0_i32;
764 None => Err(~"Invalid zone offset")
767 Err(~"Invalid zone offset")
770 '%' => parse_char(s, pos, '%'),
772 Err(format!("unknown formatting type: {}", str::from_char(ch)))
777 let mut rdr = BufReader::new(format.as_bytes());
794 let mut result = Err(~"Invalid time");
797 let range = s.char_range_at(pos);
799 let next = range.next;
802 let c = match rdr.read(buf) {
803 Ok(..) => buf[0] as char,
808 let ch = match rdr.read(buf) {
809 Ok(..) => buf[0] as char,
812 match parse_type(s, pos, ch, &mut tm) {
813 Ok(next) => pos = next,
814 Err(e) => { result = Err(e); break; }
824 if pos == len && rdr.tell().unwrap() == format.len() as u64 {
834 tm_isdst: tm.tm_isdst,
835 tm_gmtoff: tm.tm_gmtoff,
836 tm_zone: tm.tm_zone.clone(),
842 /// Formats the time according to the format string.
843 pub fn strftime(format: &str, tm: &Tm) -> ~str {
844 fn days_in_year(year: int) -> i32 {
845 if (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) {
846 366 /* Days in a leap year */
848 365 /* Days in a non-leap year */
852 fn iso_week_days(yday: i32, wday: i32) -> int {
853 /* The number of days from the first day of the first ISO week of this
854 * year to the year day YDAY with week day WDAY.
855 * ISO weeks start on Monday. The first ISO week has the year's first
857 * YDAY may be as small as yday_minimum.
859 let yday: int = yday as int;
860 let wday: int = wday as int;
861 let iso_week_start_wday: int = 1; /* Monday */
862 let iso_week1_wday: int = 4; /* Thursday */
863 let yday_minimum: int = 366;
864 /* Add enough to the first operand of % to make it nonnegative. */
865 let big_enough_multiple_of_7: int = (yday_minimum / 7 + 2) * 7;
867 yday - (yday - wday + iso_week1_wday + big_enough_multiple_of_7) % 7
868 + iso_week1_wday - iso_week_start_wday
871 fn iso_week(ch:char, tm: &Tm) -> ~str {
872 let mut year: int = tm.tm_year as int + 1900;
873 let mut days: int = iso_week_days (tm.tm_yday, tm.tm_wday);
876 /* This ISO week belongs to the previous year. */
878 days = iso_week_days (tm.tm_yday + (days_in_year(year)), tm.tm_wday);
880 let d: int = iso_week_days (tm.tm_yday - (days_in_year(year)),
883 /* This ISO week belongs to the next year. */
890 'G' => format!("{}", year),
891 'g' => format!("{:02d}", (year % 100 + 100) % 100),
892 'V' => format!("{:02d}", days / 7 + 1),
897 fn parse_type(ch: char, tm: &Tm) -> ~str {
898 let die = || format!("strftime: can't understand this format {} ", ch);
900 'A' => match tm.tm_wday as int {
910 'a' => match tm.tm_wday as int {
920 'B' => match tm.tm_mon as int {
935 'b' | 'h' => match tm.tm_mon as int {
950 'C' => format!("{:02d}", (tm.tm_year as int + 1900) / 100),
952 format!("{} {} {} {} {}",
965 'd' => format!("{:02d}", tm.tm_mday),
966 'e' => format!("{:2d}", tm.tm_mday),
967 'f' => format!("{:09d}", tm.tm_nsec),
974 'G' => iso_week('G', tm),
975 'g' => iso_week('g', tm),
976 'H' => format!("{:02d}", tm.tm_hour),
978 let mut h = tm.tm_hour;
980 if h > 12 { h -= 12 }
983 'j' => format!("{:03d}", tm.tm_yday + 1),
984 'k' => format!("{:2d}", tm.tm_hour),
986 let mut h = tm.tm_hour;
988 if h > 12 { h -= 12 }
991 'M' => format!("{:02d}", tm.tm_min),
992 'm' => format!("{:02d}", tm.tm_mon + 1),
994 'P' => if (tm.tm_hour as int) < 12 { ~"am" } else { ~"pm" },
995 'p' => if (tm.tm_hour as int) < 12 { ~"AM" } else { ~"PM" },
1002 format!("{}:{}:{} {}",
1003 parse_type('I', tm),
1004 parse_type('M', tm),
1005 parse_type('S', tm),
1006 parse_type('p', tm))
1008 'S' => format!("{:02d}", tm.tm_sec),
1009 's' => format!("{}", tm.to_timespec().sec),
1012 parse_type('H', tm),
1013 parse_type('M', tm),
1014 parse_type('S', tm))
1017 'U' => format!("{:02d}", (tm.tm_yday - tm.tm_wday + 7) / 7),
1019 let i = tm.tm_wday as int;
1020 (if i == 0 { 7 } else { i }).to_str()
1022 'V' => iso_week('V', tm),
1025 parse_type('e', tm),
1026 parse_type('b', tm),
1027 parse_type('Y', tm))
1029 'W' => format!("{:02d}", (tm.tm_yday - (tm.tm_wday - 1 + 7) % 7 + 7)
1031 'w' => (tm.tm_wday as int).to_str(),
1032 'Y' => (tm.tm_year as int + 1900).to_str(),
1033 'y' => format!("{:02d}", (tm.tm_year as int + 1900) % 100),
1034 'Z' => tm.tm_zone.clone(),
1036 let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
1037 let mut m = num::abs(tm.tm_gmtoff) / 60_i32;
1040 format!("{}{:02d}{:02d}", sign, h, m)
1042 '+' => tm.rfc3339(),
1050 let mut rdr = BufReader::new(format.as_bytes());
1053 let ch = match rdr.read(b) {
1059 rdr.read(b).unwrap();
1060 let s = parse_type(b[0] as char, tm);
1061 buf.push_all(s.as_bytes());
1063 ch => buf.push(ch as u8)
1067 str::from_utf8_owned(buf).unwrap()
1072 use super::{Timespec, get_time, precise_time_ns, precise_time_s, tzset,
1073 at_utc, at, strptime};
1076 use std::result::{Err, Ok};
1079 fn set_time_zone() {
1081 // Windows crt doesn't see any environment variable set by
1082 // `SetEnvironmentVariable`, which `os::setenv` internally uses.
1083 // It is why we use `putenv` here.
1085 fn _putenv(envstring: *libc::c_char) -> libc::c_int;
1089 // Windows does not understand "America/Los_Angeles".
1090 // PST+08 may look wrong, but not! "PST" indicates
1091 // the name of timezone. "+08" means UTC = local + 08.
1092 "TZ=PST+08".with_c_str(|env| {
1098 #[cfg(not(windows))]
1099 fn set_time_zone() {
1101 os::setenv("TZ", "America/Los_Angeles");
1105 fn test_get_time() {
1106 static SOME_RECENT_DATE: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
1107 static SOME_FUTURE_DATE: i64 = 1577836800i64; // 2020-01-01T00:00:00Z
1109 let tv1 = get_time();
1110 debug!("tv1={:?} sec + {:?} nsec", tv1.sec as uint, tv1.nsec as uint);
1112 assert!(tv1.sec > SOME_RECENT_DATE);
1113 assert!(tv1.nsec < 1000000000i32);
1115 let tv2 = get_time();
1116 debug!("tv2={:?} sec + {:?} nsec", tv2.sec as uint, tv2.nsec as uint);
1118 assert!(tv2.sec >= tv1.sec);
1119 assert!(tv2.sec < SOME_FUTURE_DATE);
1120 assert!(tv2.nsec < 1000000000i32);
1121 if tv2.sec == tv1.sec {
1122 assert!(tv2.nsec >= tv1.nsec);
1126 fn test_precise_time() {
1127 let s0 = precise_time_s();
1128 debug!("s0={} sec", f64::to_str_digits(s0, 9u));
1131 let ns0 = precise_time_ns();
1132 let ns1 = precise_time_ns();
1133 debug!("ns0={:?} ns", ns0);
1134 debug!("ns1={:?} ns", ns1);
1135 assert!(ns1 >= ns0);
1137 let ns2 = precise_time_ns();
1138 debug!("ns2={:?} ns", ns2);
1139 assert!(ns2 >= ns1);
1145 let time = Timespec::new(1234567890, 54321);
1146 let utc = at_utc(time);
1148 assert_eq!(utc.tm_sec, 30_i32);
1149 assert_eq!(utc.tm_min, 31_i32);
1150 assert_eq!(utc.tm_hour, 23_i32);
1151 assert_eq!(utc.tm_mday, 13_i32);
1152 assert_eq!(utc.tm_mon, 1_i32);
1153 assert_eq!(utc.tm_year, 109_i32);
1154 assert_eq!(utc.tm_wday, 5_i32);
1155 assert_eq!(utc.tm_yday, 43_i32);
1156 assert_eq!(utc.tm_isdst, 0_i32);
1157 assert_eq!(utc.tm_gmtoff, 0_i32);
1158 assert_eq!(utc.tm_zone, ~"UTC");
1159 assert_eq!(utc.tm_nsec, 54321_i32);
1165 let time = Timespec::new(1234567890, 54321);
1166 let local = at(time);
1168 debug!("time_at: {:?}", local);
1170 assert_eq!(local.tm_sec, 30_i32);
1171 assert_eq!(local.tm_min, 31_i32);
1172 assert_eq!(local.tm_hour, 15_i32);
1173 assert_eq!(local.tm_mday, 13_i32);
1174 assert_eq!(local.tm_mon, 1_i32);
1175 assert_eq!(local.tm_year, 109_i32);
1176 assert_eq!(local.tm_wday, 5_i32);
1177 assert_eq!(local.tm_yday, 43_i32);
1178 assert_eq!(local.tm_isdst, 0_i32);
1179 assert_eq!(local.tm_gmtoff, -28800_i32);
1181 // FIXME (#2350): We should probably standardize on the timezone
1183 let zone = &local.tm_zone;
1184 assert!(*zone == ~"PST" || *zone == ~"Pacific Standard Time");
1186 assert_eq!(local.tm_nsec, 54321_i32);
1189 fn test_to_timespec() {
1192 let time = Timespec::new(1234567890, 54321);
1193 let utc = at_utc(time);
1195 assert_eq!(utc.to_timespec(), time);
1196 assert_eq!(utc.to_local().to_timespec(), time);
1199 fn test_conversions() {
1202 let time = Timespec::new(1234567890, 54321);
1203 let utc = at_utc(time);
1204 let local = at(time);
1206 assert!(local.to_local() == local);
1207 assert!(local.to_utc() == utc);
1208 assert!(local.to_utc().to_local() == local);
1209 assert!(utc.to_utc() == utc);
1210 assert!(utc.to_local() == local);
1211 assert!(utc.to_local().to_utc() == utc);
1214 fn test_strptime() {
1217 match strptime("", "") {
1219 assert!(tm.tm_sec == 0_i32);
1220 assert!(tm.tm_min == 0_i32);
1221 assert!(tm.tm_hour == 0_i32);
1222 assert!(tm.tm_mday == 0_i32);
1223 assert!(tm.tm_mon == 0_i32);
1224 assert!(tm.tm_year == 0_i32);
1225 assert!(tm.tm_wday == 0_i32);
1226 assert!(tm.tm_isdst == 0_i32);
1227 assert!(tm.tm_gmtoff == 0_i32);
1228 assert!(tm.tm_zone == ~"");
1229 assert!(tm.tm_nsec == 0_i32);
1234 let format = "%a %b %e %T.%f %Y";
1235 assert_eq!(strptime("", format), Err(~"Invalid time"));
1236 assert!(strptime("Fri Feb 13 15:31:30", format)
1237 == Err(~"Invalid time"));
1239 match strptime("Fri Feb 13 15:31:30.01234 2009", format) {
1242 assert!(tm.tm_sec == 30_i32);
1243 assert!(tm.tm_min == 31_i32);
1244 assert!(tm.tm_hour == 15_i32);
1245 assert!(tm.tm_mday == 13_i32);
1246 assert!(tm.tm_mon == 1_i32);
1247 assert!(tm.tm_year == 109_i32);
1248 assert!(tm.tm_wday == 5_i32);
1249 assert!(tm.tm_yday == 0_i32);
1250 assert!(tm.tm_isdst == 0_i32);
1251 assert!(tm.tm_gmtoff == 0_i32);
1252 assert!(tm.tm_zone == ~"");
1253 assert!(tm.tm_nsec == 12340000_i32);
1257 fn test(s: &str, format: &str) -> bool {
1258 match strptime(s, format) {
1259 Ok(ref tm) => tm.strftime(format) == s.to_owned(),
1273 for day in days.iter() {
1274 assert!(test(*day, "%A"));
1286 for day in days.iter() {
1287 assert!(test(*day, "%a"));
1304 for day in months.iter() {
1305 assert!(test(*day, "%B"));
1322 for day in months.iter() {
1323 assert!(test(*day, "%b"));
1326 assert!(test("19", "%C"));
1327 assert!(test("Fri Feb 13 23:31:30 2009", "%c"));
1328 assert!(test("02/13/09", "%D"));
1329 assert!(test("03", "%d"));
1330 assert!(test("13", "%d"));
1331 assert!(test(" 3", "%e"));
1332 assert!(test("13", "%e"));
1333 assert!(test("2009-02-13", "%F"));
1334 assert!(test("03", "%H"));
1335 assert!(test("13", "%H"));
1336 assert!(test("03", "%I")); // FIXME (#2350): flesh out
1337 assert!(test("11", "%I")); // FIXME (#2350): flesh out
1338 assert!(test("044", "%j"));
1339 assert!(test(" 3", "%k"));
1340 assert!(test("13", "%k"));
1341 assert!(test(" 1", "%l"));
1342 assert!(test("11", "%l"));
1343 assert!(test("03", "%M"));
1344 assert!(test("13", "%M"));
1345 assert!(test("\n", "%n"));
1346 assert!(test("am", "%P"));
1347 assert!(test("pm", "%P"));
1348 assert!(test("AM", "%p"));
1349 assert!(test("PM", "%p"));
1350 assert!(test("23:31", "%R"));
1351 assert!(test("11:31:30 AM", "%r"));
1352 assert!(test("11:31:30 PM", "%r"));
1353 assert!(test("03", "%S"));
1354 assert!(test("13", "%S"));
1355 assert!(test("15:31:30", "%T"));
1356 assert!(test("\t", "%t"));
1357 assert!(test("1", "%u"));
1358 assert!(test("7", "%u"));
1359 assert!(test("13-Feb-2009", "%v"));
1360 assert!(test("0", "%w"));
1361 assert!(test("6", "%w"));
1362 assert!(test("2009", "%Y"));
1363 assert!(test("09", "%y"));
1364 assert!(strptime("UTC", "%Z").unwrap().tm_zone ==
1366 assert!(strptime("PST", "%Z").unwrap().tm_zone ==
1368 assert!(strptime("-0000", "%z").unwrap().tm_gmtoff ==
1370 assert!(strptime("-0800", "%z").unwrap().tm_gmtoff ==
1372 assert!(test("%", "%%"));
1375 assert_eq!(strptime("360", "%Y-%m-%d"), Err(~"Invalid year"))
1381 let time = Timespec::new(1234567890, 54321);
1382 let utc = at_utc(time);
1383 let local = at(time);
1385 debug!("test_ctime: {:?} {:?}", utc.ctime(), local.ctime());
1387 assert_eq!(utc.ctime(), ~"Fri Feb 13 23:31:30 2009");
1388 assert_eq!(local.ctime(), ~"Fri Feb 13 15:31:30 2009");
1391 fn test_strftime() {
1394 let time = Timespec::new(1234567890, 54321);
1395 let utc = at_utc(time);
1396 let local = at(time);
1398 assert_eq!(local.strftime(""), ~"");
1399 assert_eq!(local.strftime("%A"), ~"Friday");
1400 assert_eq!(local.strftime("%a"), ~"Fri");
1401 assert_eq!(local.strftime("%B"), ~"February");
1402 assert_eq!(local.strftime("%b"), ~"Feb");
1403 assert_eq!(local.strftime("%C"), ~"20");
1404 assert_eq!(local.strftime("%c"), ~"Fri Feb 13 15:31:30 2009");
1405 assert_eq!(local.strftime("%D"), ~"02/13/09");
1406 assert_eq!(local.strftime("%d"), ~"13");
1407 assert_eq!(local.strftime("%e"), ~"13");
1408 assert_eq!(local.strftime("%f"), ~"000054321");
1409 assert_eq!(local.strftime("%F"), ~"2009-02-13");
1410 assert_eq!(local.strftime("%G"), ~"2009");
1411 assert_eq!(local.strftime("%g"), ~"09");
1412 assert_eq!(local.strftime("%H"), ~"15");
1413 assert_eq!(local.strftime("%I"), ~"03");
1414 assert_eq!(local.strftime("%j"), ~"044");
1415 assert_eq!(local.strftime("%k"), ~"15");
1416 assert_eq!(local.strftime("%l"), ~" 3");
1417 assert_eq!(local.strftime("%M"), ~"31");
1418 assert_eq!(local.strftime("%m"), ~"02");
1419 assert_eq!(local.strftime("%n"), ~"\n");
1420 assert_eq!(local.strftime("%P"), ~"pm");
1421 assert_eq!(local.strftime("%p"), ~"PM");
1422 assert_eq!(local.strftime("%R"), ~"15:31");
1423 assert_eq!(local.strftime("%r"), ~"03:31:30 PM");
1424 assert_eq!(local.strftime("%S"), ~"30");
1425 assert_eq!(local.strftime("%s"), ~"1234567890");
1426 assert_eq!(local.strftime("%T"), ~"15:31:30");
1427 assert_eq!(local.strftime("%t"), ~"\t");
1428 assert_eq!(local.strftime("%U"), ~"06");
1429 assert_eq!(local.strftime("%u"), ~"5");
1430 assert_eq!(local.strftime("%V"), ~"07");
1431 assert_eq!(local.strftime("%v"), ~"13-Feb-2009");
1432 assert_eq!(local.strftime("%W"), ~"06");
1433 assert_eq!(local.strftime("%w"), ~"5");
1434 assert_eq!(local.strftime("%X"), ~"15:31:30"); // FIXME (#2350): support locale
1435 assert_eq!(local.strftime("%x"), ~"02/13/09"); // FIXME (#2350): support locale
1436 assert_eq!(local.strftime("%Y"), ~"2009");
1437 assert_eq!(local.strftime("%y"), ~"09");
1438 assert_eq!(local.strftime("%+"), ~"2009-02-13T15:31:30-08:00");
1440 // FIXME (#2350): We should probably standardize on the timezone
1442 let zone = local.strftime("%Z");
1443 assert!(zone == ~"PST" || zone == ~"Pacific Standard Time");
1445 assert_eq!(local.strftime("%z"), ~"-0800");
1446 assert_eq!(local.strftime("%%"), ~"%");
1448 // FIXME (#2350): We should probably standardize on the timezone
1450 let rfc822 = local.rfc822();
1451 let prefix = ~"Fri, 13 Feb 2009 15:31:30 ";
1452 assert!(rfc822 == prefix + "PST" || rfc822 == prefix + "Pacific Standard Time");
1454 assert_eq!(local.ctime(), ~"Fri Feb 13 15:31:30 2009");
1455 assert_eq!(local.rfc822z(), ~"Fri, 13 Feb 2009 15:31:30 -0800");
1456 assert_eq!(local.rfc3339(), ~"2009-02-13T15:31:30-08:00");
1458 assert_eq!(utc.ctime(), ~"Fri Feb 13 23:31:30 2009");
1459 assert_eq!(utc.rfc822(), ~"Fri, 13 Feb 2009 23:31:30 GMT");
1460 assert_eq!(utc.rfc822z(), ~"Fri, 13 Feb 2009 23:31:30 -0000");
1461 assert_eq!(utc.rfc3339(), ~"2009-02-13T23:31:30Z");
1464 fn test_timespec_eq_ord() {
1465 let a = &Timespec::new(-2, 1);
1466 let b = &Timespec::new(-1, 2);
1467 let c = &Timespec::new(1, 2);
1468 let d = &Timespec::new(2, 1);
1469 let e = &Timespec::new(2, 1);
1496 #[ignore(cfg(target_os = "android"))] // FIXME #10958
1498 // The tests race on tzset. So instead of having many independent
1499 // tests, we will just call the functions now.
1501 test_precise_time();
1509 test_timespec_eq_ord();