Nothing
Sys.setlocale("LC_TIME", "C")
test_that("parsers throw on invalid tz argument", {
expect_error(ymd("2019-01-01", tz = NA))
expect_error(ymd("2019-01-01", tz = c("UTC", "UTC")))
expect_error(parse_date_time2("2019-01-01", "ymd", tz = NA))
})
test_that("ymd functions correctly parse dates separated by -", {
expect_equal(ymd("2010-01-02"), as.Date("2010-01-02"))
expect_equal(ymd("10-01-02"), as.Date("2010-01-02"))
expect_equal(ydm("2010-02-01"), as.Date("2010-01-02"))
expect_equal(mdy("01-02-2010"), as.Date("2010-01-02"))
expect_equal(myd("01-2010-02"), as.Date("2010-01-02"))
expect_equal(dmy("02-01-2010"), as.Date("2010-01-02"))
expect_equal(dym("02-2010-01"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010-01-02", "2010-01-03")), as.Date(c("2010-01-02", "2010-01-03")))
})
test_that("ymd functions correctly parse dates separated by /", {
expect_equal(ymd("2010/01/02"), as.Date("2010-01-02"))
expect_equal(ymd("10/01/02"), as.Date("2010-01-02"))
expect_equal(ydm("2010/02/01"), as.Date("2010-01-02"))
expect_equal(mdy("01/02/2010"), as.Date("2010-01-02"))
expect_equal(myd("01/2010/02"), as.Date("2010-01-02"))
expect_equal(dmy("02/01/2010"), as.Date("2010-01-02"))
expect_equal(dym("02/2010/01"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010/01/02", "2010/01/03")), as.Date(c("2010-01-02", "2010-01-03")))
})
test_that("ymd functions correctly parse dates separated by .", {
expect_equal(ymd("2010.01.02"), as.Date("2010-01-02"))
expect_equal(ymd("10.01.02"), as.Date("2010-01-02"))
expect_equal(ydm("2010.02.01"), as.Date("2010-01-02"))
expect_equal(mdy("01.02.2010"), as.Date("2010-01-02"))
expect_equal(myd("01.2010.02"), as.Date("2010-01-02"))
expect_equal(dmy("02.01.2010"), as.Date("2010-01-02"))
expect_equal(dym("02.2010.01"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010.01.02", "2010.01.03")), as.Date(c("2010-01-02", "2010-01-03")))
})
test_that("ymd functions correctly parse dates separated by ,", {
expect_equal(ymd("2010,01,02"), as.Date("2010-01-02"))
expect_equal(ymd("10,01,02"), as.Date("2010-01-02"))
expect_equal(ydm("2010,02,01"), as.Date("2010-01-02"))
expect_equal(mdy("01,02,2010"), as.Date("2010-01-02"))
expect_equal(myd("01,2010,02"), as.Date("2010-01-02"))
expect_equal(dmy("02,01,2010"), as.Date("2010-01-02"))
expect_equal(dym("02,2010,01"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010,01,02", "2010,01,03")), as.Date(c("2010-01-02", "2010-01-03")))
})
test_that("ymd functions correctly parse dates separated by :", {
expect_equal(ymd("2010:01:02"), as.Date("2010-01-02"))
expect_equal(ymd("10:01:02"), as.Date("2010-01-02"))
expect_equal(ydm("2010:02:01"), as.Date("2010-01-02"))
expect_equal(mdy("01:02:2010"), as.Date("2010-01-02"))
expect_equal(myd("01:2010:02"), as.Date("2010-01-02"))
expect_equal(dmy("02:01:2010"), as.Date("2010-01-02"))
expect_equal(dym("02:2010:01"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010:01:02", "2010:01:03")), as.Date(c("2010-01-02", "2010-01-03")))
})
test_that("ymd functions correctly parse dates with no separators", {
expect_equal(ymd("20100102"), as.Date("2010-01-02"))
expect_equal(ydm("20100201"), as.Date("2010-01-02"))
expect_equal(mdy("01022010"), as.Date("2010-01-02"))
expect_equal(myd("01201002"), as.Date("2010-01-02"))
expect_equal(dmy("02012010"), as.Date("2010-01-02"))
expect_equal(dym("02201001"), as.Date("2010-01-02"))
expect_equal(ymd(c("20100102", "20100103")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("100102"), as.Date("2010-01-02"))
expect_equal(ymd("20100102"), as.Date("2010-01-02"))
expect_equal(ydm("20100201"), as.Date("2010-01-02"))
expect_equal(mdy("01022010"), as.Date("2010-01-02"))
expect_equal(myd("01201002"), as.Date("2010-01-02"))
expect_equal(dmy("02012010"), as.Date("2010-01-02"))
expect_equal(dym("02201001"), as.Date("2010-01-02"))
expect_equal(ymd(c("20100102", "20100103")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("100102"), as.Date("2010-01-02"))
})
test_that("ymd functions correctly parse dates with no separators", {
expect_equal(ymd("20100102"), as.Date("2010-01-02"))
expect_equal(ydm("20100201"), as.Date("2010-01-02"))
expect_equal(mdy("01022010"), as.Date("2010-01-02"))
expect_equal(myd("01201002"), as.Date("2010-01-02"))
expect_equal(dmy("02012010"), as.Date("2010-01-02"))
expect_equal(dym("02201001"), as.Date("2010-01-02"))
expect_equal(ymd(c("20100102", "20100103")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("100102"), as.Date("2010-01-02"))
expect_equal(ymd("20100102"), as.Date("2010-01-02"))
expect_equal(ydm("20100201"), as.Date("2010-01-02"))
expect_equal(mdy("01022010"), as.Date("2010-01-02"))
expect_equal(myd("01201002"), as.Date("2010-01-02"))
expect_equal(dmy("02012010"), as.Date("2010-01-02"))
expect_equal(dym("02201001"), as.Date("2010-01-02"))
expect_equal(ymd(c("20100102", "20100103")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("100102"), as.Date("2010-01-02"))
})
test_that("ymd parser warns on failed parsing", {
expect_warning(ymd("2018-02-30", quiet = FALSE), ".*failed to parse")
})
test_that("ymd function correctly parse b and B formats", {
expect_equal(ymd("2004-Jan-15"), as.Date("2004-01-15"))
expect_equal(ymd("2004-January-15"), as.Date("2004-01-15"))
expect_equal(
ymd("2004-Jan-15", "2004-Feb-15", "1904-Jan-15", "1904-Feb-15"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(
ymd("2004-Jan-15", "2004-Feb-15", "1904-January-15", "1904-February-15"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(mdy("Jan-15-2004"), as.Date("2004-01-15"))
expect_equal(mdy("January-15-2004"), as.Date("2004-01-15"))
expect_equal(
mdy("Jan-15-2004", "Feb-15-2004", "Jan-15-1904", "Feb-15-1904"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(
mdy("Jan-15-2004", "Feb-15-2004", "January-15-1904", "February-15-1904"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
})
test_that("ymd function correctly parse b and B formats", {
expect_equal(ymd("2004-Jan-15"), as.Date("2004-01-15"))
expect_equal(ymd("2004-January-15"), as.Date("2004-01-15"))
expect_equal(
ymd("2004-Jan-15", "2004-Feb-15", "1904-Jan-15", "1904-Feb-15"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(
ymd("2004-Jan-15", "2004-Feb-15", "1904-January-15", "1904-February-15"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(mdy("Jan-15-2004"), as.Date("2004-01-15"))
expect_equal(mdy("January-15-2004"), as.Date("2004-01-15"))
expect_equal(
mdy("Jan-15-2004", "Feb-15-2004", "Jan-15-1904", "Feb-15-1904"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
expect_equal(
mdy("Jan-15-2004", "Feb-15-2004", "January-15-1904", "February-15-1904"),
as.Date(c("2004-01-15 UTC", "2004-02-15 UTC", "1904-01-15 UTC", "1904-02-15 UTC"))
)
})
test_that("ymd functions correctly parse dates with no separators and b and B formats", {
expect_equal(ymd("2010January02"), as.Date("2010-01-02"))
expect_equal(ydm("201002January"), as.Date("2010-01-02"))
expect_equal(mdy("January022010"), as.Date("2010-01-02"))
expect_equal(myd("January201002"), as.Date("2010-01-02"))
expect_equal(dmy("02January2010"), as.Date("2010-01-02"))
expect_equal(dym("022010January"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010January02", "2010January03")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("10January02"), as.Date("2010-01-02"))
expect_equal(ymd("2010January02"), as.Date("2010-01-02"))
expect_equal(ydm("201002January"), as.Date("2010-01-02"))
expect_equal(mdy("January022010"), as.Date("2010-01-02"))
expect_equal(myd("January201002"), as.Date("2010-01-02"))
expect_equal(dmy("02January2010"), as.Date("2010-01-02"))
expect_equal(dym("022010January"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010January02", "2010January03")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("10January02"), as.Date("2010-01-02"))
expect_equal(ymd("2010Jan02"), as.Date("2010-01-02"))
expect_equal(ydm("201002Jan"), as.Date("2010-01-02"))
expect_equal(mdy("Jan022010"), as.Date("2010-01-02"))
expect_equal(myd("Jan201002"), as.Date("2010-01-02"))
expect_equal(dmy("02Jan2010"), as.Date("2010-01-02"))
expect_equal(dym("022010Jan"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010Jan02", "2010Jan03")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("10Jan02"), as.Date("2010-01-02"))
expect_equal(ymd("2010Jan02"), as.Date("2010-01-02"))
expect_equal(ydm("201002Jan"), as.Date("2010-01-02"))
expect_equal(mdy("Jan022010"), as.Date("2010-01-02"))
expect_equal(myd("Jan201002"), as.Date("2010-01-02"))
expect_equal(dmy("02Jan2010"), as.Date("2010-01-02"))
expect_equal(dym("022010Jan"), as.Date("2010-01-02"))
expect_equal(ymd(c("2010Jan02", "2010Jan03")), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd("10Jan02"), as.Date("2010-01-02"))
})
test_that("ymd functions correctly parse dates with no separators and no quotes", {
expect_equal(ymd(20100102), as.Date("2010-01-02"))
expect_equal(ydm(20100201), as.Date("2010-01-02"))
expect_equal(mdy(01022010), as.Date("2010-01-02"))
expect_equal(myd(01201002), as.Date("2010-01-02"))
expect_equal(dmy(02012010), as.Date("2010-01-02"))
expect_equal(dym(02201001), as.Date("2010-01-02"))
expect_equal(ymd(c(20100102, 20100103)), as.Date(c("2010-01-02", "2010-01-03")))
expect_equal(ymd(100102), as.Date("2010-01-02"))
expect_equal(ymd_hms(20100102235959), as.POSIXct("2010-01-02 23:59:59", tz = "UTC"))
})
test_that("all numbers are correctly converted into character for parsing", {
# Conversion to character of numbers with 000000 at the end with as.character()
# may outputs scientific notation depending on the value of the 'scipen' option.
# .num_to_date() uses format() to avoid that. Check that it does indeed work
expect_equal(ymd_hms(20100102000000), as.POSIXct("2010-01-02 00:00:00", tz = "UTC"))
expect_equal(.num_to_date(20100102000000), "20100102000000")
})
test_that("ymd functions parse absurd formats as NA's", {
## should not through errors, just as as.POSIX and strptime
pna <- as.Date(NA)
expect_equal(ymd(201001023, quiet = TRUE), pna)
expect_equal(ydm(20103201, quiet = TRUE), pna)
expect_equal(mdy(13022010, quiet = TRUE), pna)
expect_equal(myd(01201033, quiet = TRUE), pna)
expect_equal(dmy(02222010, quiet = TRUE), pna)
expect_equal(dym(022010013, quiet = TRUE), pna)
pna <- with_tz(as.POSIXct(NA), "UTC")
expect_equal(ymd_hms("2010-01-023 23:59:59", quiet = TRUE), pna)
expect_equal(ymd_hms("2010-01-023 23:59:59.34", quiet = TRUE), pna)
expect_equal(ymd_hms("201001023235959.34", quiet = TRUE), pna)
expect_equal(ymd(c(201001024, 20100103), quiet = TRUE), as.Date(c(NA, "2010-01-03")))
})
test_that("ymd functions give warning when parsing absurd formats", {
## should not through errors, just as as.POSIX and strptime
expect_warning(ymd(201001023))
expect_warning(ydm(20103201))
expect_warning(mdy(13022010))
expect_warning(myd(01201033))
expect_warning(dmy(02222010))
expect_warning(dym(022010013))
expect_warning(ymd_hms("2010-01-023 23:59:59"))
expect_warning(ymd_hms("2010-01-023 23:59:59.34"))
expect_warning(ymd_hms("201001023235959.34"))
expect_warning(ymd(c(201001024, 20100103)))
})
test_that("cutoff_2000 works as expected", {
dates <- c("20-02-03", "67-02-03", "68-02-03", "69-02-03", "99-02-03", "00-02-03")
expect_equal(
parse_date_time2(dates, "ymd"),
ymd(c("2020-02-03", "2067-02-03", "2068-02-03", "1969-02-03", "1999-02-03", "2000-02-03"), tz = "UTC")
)
expect_equal(
parse_date_time2(dates, "ymd", cutoff_2000 = 67),
ymd(c("2020-02-03", "2067-02-03", "1968-02-03", "1969-02-03", "1999-02-03", "2000-02-03"), tz = "UTC")
)
expect_equal(
parse_date_time2(dates, "ymd", cutoff_2000 = 20),
ymd(c("2020-02-03", "1967-02-03", "1968-02-03", "1969-02-03", "1999-02-03", "2000-02-03"), tz = "UTC")
)
expect_equal(
parse_date_time2(dates, "ymd", cutoff_2000 = 0),
ymd(c("1920-02-03", "1967-02-03", "1968-02-03", "1969-02-03", "1999-02-03", "2000-02-03"), tz = "UTC")
)
expect_equal(
parse_date_time2(dates, "ymd", cutoff_2000 = -1),
ymd(c("1920-02-03", "1967-02-03", "1968-02-03", "1969-02-03", "1999-02-03", "1900-02-03"), tz = "UTC")
)
})
test_that("parse_date_time2 parses multiple formats", {
skip("FIXME: ymd_hms OSz parsing")
x <- c(
"2007-08-01 00:01:02", "2007-08-01 00:01:02+0100", "2007-08-01 00:01:02",
"2007-08-01 00:01:02.55", "2007-08-01", "2007-08-01 00:01:02.55+0200"
)
y1 <- ymd_hms(x, truncated = 3)
y2 <- parse_date_time2(x, c("YmdHMS", "YmdHMSz", "Ymd", "YmdHMOS", "YmdHMOSz"))
expect_equal(y1, y2)
y3 <- parse_date_time2(x, c("YmdHMS", "YmdHMSz", "Ymd", "YmdHMOS", "YmdHMOSz"), lt = TRUE)
expect_equal(as.POSIXlt(y1), y3)
expect_equal(y1, as.POSIXct(y3))
## data.frame(x, y1, y2, y3)
})
test_that("fast_strptime parses multiple formats", {
skip("FIXME: ymd_hms OSz parsing")
x <- c(
"2007-08-01 00:01:02", "2007-08-01 00:01:02+0100", "2007-08-01 00:01:02",
"2007-08-01 00:01:02.55", "2007-08-01", "2007-08-01 00:01:02.55+0200"
)
fmts <- c(
"%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M:%S%z", "%Y-%m-%d",
"%Y-%m-%d %H:%M:%OS", "%Y-%m-%d %H:%M:%OS%z"
)
y1 <- ymd_hms(x, truncated = 3)
y2 <- fast_strptime(x, fmts)
expect_equal(y1, y2)
y3 <- fast_strptime(x, fmts, lt = FALSE)
expect_equal(as.POSIXlt(y1), y3)
expect_equal(y1, as.POSIXct(y3))
## data.frame(x, y1, y2, y3)
})
test_that("fast_strptime ignores multiple spaces", {
# #911
expect_equal(
fast_strptime("8/1/2012 8:02:51.397000 AM", "%m/%d/%Y %I:%M:%OS %p"),
fast_strptime("8/1/2012 8:02:51.397000 AM", "%m/%d/%Y %I:%M:%OS %p")
)
expect_equal(
fast_strptime("8/1/2012 8:02:51.397000 AM", "%m/%d/%Y %I:%M:%OS %p"),
fast_strptime("8/1/2012 8:02:51.397000 AM", "%m/%d/%Y %I:%M:%OS %p")
)
})
test_that("0 month and 0 day in date produces NA", {
expect_equal(ymd(c("2013-1-1", "2013-0-1"), quiet = TRUE), as.Date(c("2013-01-01", NA)))
expect_equal(ymd(c("2013-1-1", "2013-1-0"), quiet = TRUE), as.Date(c("2013-01-01", NA)))
expect_equal(ymd("2013-1-0", quiet = TRUE), as.Date(as.character(NA)))
})
test_that("ymd_hms correctly handles a variety of formats", {
expect_equal(
ymd_hms("2010-01-02 23:59:59"),
as.POSIXct("2010-01-02 23:59:59", tz = "UTC")
)
expect_equal(
ymd_hms("2010,01,02 23.59.59"),
as.POSIXct("2010-01-02 23:59:59", tz = "UTC")
)
expect_equal(
ymd_hms("2010,01,02 23.59.59.9"),
as.POSIXct("2010-01-02 23:59:59.9 UTC", tz = "UTC")
)
expect_equal(
ymd_hms("2010/01/02 23/59/59"),
as.POSIXct("2010-01-02 23:59:59", tz = "UTC")
)
expect_equal(
ymd_hms("2010:01:02-23:59:59"),
as.POSIXct("2010-01-02 23:59:59", tz = "UTC")
)
## VS: Next doesn't parse on my machine. It's OS specific.
## expect_equal(ymd_hms("2010-01-02 23:59:61"), as.POSIXct(
## "2010-01-03 00:00:01", tz = "UTC"))
## expect_equal(ymd_hms(c("2010-01-02 23:59:61",
## "2010-01-02 00:00:00")), as.POSIXct(
## c("2010-01-03 00:00:01", "2010-01-02 00:00:00"), tz =
## "UTC"))
expect_equal(
ymd_hms("10-01-02 23:59:59"),
as.POSIXct("2010-01-02 23:59:59", tz = "UTC")
)
})
test_that("parse_date_time handles multiple month formats correctly", {
dates <- c("09-01-17", "02-Sep-17")
expect_equal(
parse_date_time(dates, orders = c("dmy"), locale = "C"),
ymd(c("2017-01-09", "2017-09-02"), tz = "UTC")
)
expect_equal(
parse_date_time(dates, orders = c("dby"), locale = "C", quiet = T),
ymd(c(NA, "2017-09-02"), tz = "UTC")
)
## mdy & dby
expect_equal(
parse_date_time(dates, orders = c("mdy", "dby")),
ymd(c("2017-09-01", "2017-09-02"), tz = "UTC")
)
## mdY & dby/Y
expect_equal(
parse_date_time(c("09-01-2017", "02-Sep-17"), orders = c("mdY", "dby")),
ymd(c("2017-09-01", "2017-09-02"), tz = "UTC")
)
expect_equal(
parse_date_time(c("09-01-2017", "02-Sep-2017"), orders = c("mdY", "dbY")),
ymd(c("2017-09-01", "2017-09-02"), tz = "UTC")
)
## mdy/Y & dby/Y, with no mdy/Y in x
expect_equal(
parse_date_time("09-01-17", orders = c("mdy", "dby", "dbY")),
ymd(c("2017-09-01"), tz = "UTC")
)
})
test_that("parse_date_time handles multiple partial month formats correctly", {
expect_equal(
parse_date_time("May-2010", orders = "%b-%Y"),
ymd("2010-05-01", tz = "UTC")
)
expect_equal(
parse_date_time(c("02-May-2010", "May-2010", "2010"), orders = c("dbY", "bY", "Y")),
ymd(c("2010-05-02", "2010-05-01", "2010-01-01"), tz = "UTC")
)
expect_equal(
parse_date_time(c("02-May-2010", "May-03-2010", "05-03-2010", "May-2010", "2010"),
orders = c("dbY", "bdY", "mdY", "bY", "Y")
),
ymd(c("2010-05-02", "2010-05-03", "2010-05-03", "2010-05-01", "2010-01-01"), tz = "UTC")
)
})
test_that("parse_date_time gives higher priority to y than to Y format", {
expect_equal(
parse_date_time(c("apr.12.50", "apr.2.2016"), orders = "mdy"),
ymd(c("2050-04-12 UTC", "2016-04-02 UTC"), tz = "UTC")
)
expect_equal(
parse_date_time(c("50.apr.12", "2016.apr.2"), orders = "ymd"),
ymd(c("2050-04-12 UTC", "2016-04-02 UTC"), tz = "UTC")
)
})
test_that("C parser correctly handles month formats", {
expect_equal(ymd_hms("2010-Jan-02 23:59:59"), as.POSIXct("2010-01-02 23:59:59", tz = "UTC"))
expect_equal(ymd_hms("2010-January-02 23:59:59"), as.POSIXct("2010-01-02 23:59:59", tz = "UTC"))
expect_equal(ymd_hms("2010-Dec-02 23:59:59"), as.POSIXct("2010-12-02 23:59:59", tz = "UTC"))
expect_equal(ymd_hms("2010-Dec-02 23:59:59"), parse_date_time2("2010-Dec-02 23:59:59", "YOmdHMS"))
expect_equal(ymd_hms("2010-Dec-02 23:59:59"), parse_date_time2("2010-Dec-02 23:59:59", "YbdHMS"))
expect_equal(ymd_hms("2010-Dec-02 03:59:59 PM"), parse_date_time2("2010-Dec-02 15:59:59", "YbdHMS"))
expect_equal(ymd_hms("2010-Dec-02 03:59:59 PM"), parse_date_time2("2010-Dec-02 03:59:59 PM", "YOmdHMSOp"))
expect_equal(ymd_hms("2010-Dec-02 23:59:59"), parse_date_time2("2010-December-02 23:59:59", "YBdHMS"))
yy <- c("10-Feb-28 23:59:59", "10-May-28 23:59:59", "10-September-28 23:59:59")
zz <- c("2010-Feb-28 23:59:59", "2010-May-28 23:59:59", "2010-September-28 23:59:59")
tt <- c("2010-02-28 23:59:59", "2010-05-28 23:59:59", "2010-09-28 23:59:59")
expect_equal(parse_date_time2(yy, "ybdHMS"), as.POSIXct(tt, tz = "UTC"))
expect_equal(parse_date_time2(zz, "YbdHMS"), as.POSIXct(tt, tz = "UTC"))
expect_equal(parse_date_time2(yy, "ybdHMS"), as.POSIXct(tt, tz = "UTC"))
expect_equal(parse_date_time2(yy, "ymdHMS"), as.POSIXct(tt, tz = "UTC"))
expect_equal(parse_date_time2(zz, "YOmdHMS"), as.POSIXct(tt, tz = "UTC"))
expect_equal(ymd_hms(c(yy, zz)), as.POSIXct(c(tt, tt), tz = "UTC"))
})
test_that("hms functions correctly handle : separators", {
expect_equal(hms("3:3:3"), hours(3) + minutes(3) + seconds(3))
expect_equal(hms("03:03:03"), hours(3) + minutes(3) + seconds(3))
expect_equal(ms("03:03"), minutes(3) + seconds(3))
expect_equal(hm("03:03"), hours(3) + minutes(3))
expect_equal(hm("03:3"), hours(3) + minutes(3))
})
test_that("hms functions correctly handle . separators", {
expect_equal(hms("3.3.3"), hours(3) + minutes(3) + seconds(3))
expect_equal(hms("03.03.03"), hours(3) + minutes(3) + seconds(3))
expect_equal(ms("03.03"), minutes(3) + seconds(3))
expect_equal(hm("03.03"), hours(3) + minutes(3))
expect_equal(hm("03.3"), hours(3) + minutes(3))
})
test_that("hms functions correctly handle space separators", {
expect_equal(hms("3 3 3"), hours(3) + minutes(3) + seconds(3))
expect_equal(hms("03 03 03"), hours(3) + minutes(3) + seconds(3))
expect_equal(ms("03 03"), minutes(3) + seconds(3))
expect_equal(hm("03 03"), hours(3) + minutes(3))
expect_equal(hm("03 3"), hours(3) + minutes(3))
})
test_that("hms functions correctly handle , separators", {
expect_equal(hms("3,3,3"), hours(3) + minutes(3) + seconds(3))
expect_equal(hms("03,03,03"), hours(3) + minutes(3) + seconds(3))
expect_equal(ms("03,03"), minutes(3) + seconds(3))
expect_equal(hm("03,03"), hours(3) + minutes(3))
expect_equal(hm("03,3"), hours(3) + minutes(3))
})
test_that("hms functions correctly handle / separators", {
expect_equal(hms("3/3/3"), hours(3) + minutes(3) + seconds(3))
expect_equal(hms("00/00/00"), hours(0) + minutes(0) + seconds(0))
expect_equal(ms("03/03"), minutes(3) + seconds(3))
expect_equal(hm("03/03"), hours(3) + minutes(3))
expect_equal(hm("03/3"), hours(3) + minutes(3))
})
test_that("hms functions correctly roll", {
expect_equal(hms("3:59:120", roll = T), period(hours = 4, minutes = 1))
expect_equal(ms("59:125", roll = T), period(hours = 1, minutes = 1, seconds = 5))
expect_equal(hm("159:125", roll = T), period(hours = 161, minutes = 5))
})
test_that("hms functions return NA on shorter inputs", {
expect_true(is.na(hms("3:3:3:4", quiet = TRUE)))
expect_true(is.na(hms("03:03", quiet = TRUE)))
expect_true(is.na(ms("03:02:01", quiet = TRUE)))
expect_true(is.na(ms("03", quiet = TRUE)))
expect_true(is.na(hm("03:03:01", quiet = TRUE)))
expect_true(is.na(hm("03", quiet = TRUE)))
})
test_that("hms functions give warning on shorter inputs", {
expect_warning(hms("3:3:3:4"))
expect_warning(hms("03:03"))
expect_warning(ms("03:02:01"))
expect_warning(ms("03"))
expect_warning(hm("03:03:01"))
expect_warning(hm("03"))
})
test_that("hms functions correctly negative components separators", {
expect_equal(hms("3-3-3"), hours(3) - minutes(3) - seconds(3))
expect_equal(hms("03-03-03"), hours(3) - minutes(3) - seconds(3))
expect_equal(ms("-03-03"), (-minutes(3) - seconds(3)))
expect_equal(hm("03-3"), hours(3) - minutes(3))
})
test_that("AM/PM indicators are parsed correctly", {
expect_equal(
parse_date_time2("12/17/1996 04:00:00 PM", "mdYHMSp"),
ymd_hms("1996-12-17 16:00:00")
)
expect_equal(
parse_date_time2("12/17/1996 04:00:00 PM", "mdYHMSOp"),
ymd_hms("1996-12-17 16:00:00")
)
expect_equal(
parse_date_time2("12/17/1996 04:00:00 AM", "mdYHMSp"),
ymd_hms("1996-12-17 04:00:00")
)
expect_equal(
parse_date_time2("12/17/1996 04:00:00 PM", "mdYHMSp", tz = "CET"),
ymd_hms("1996-12-17 16:00:00", tz = "CET")
)
expect_equal(
parse_date_time2("12/17/1996 04:00:00 TM", "mdYHMSp"),
make_datetime(NA)
)
expect_equal(
as.POSIXct(fast_strptime("1996-05-17 04:00:00 PM", "%Y-%m-%d %H:%M:%S %Op")),
ymd_hms("1996-05-17 16:00:00")
)
expect_equal(ymd_hms("1996-05-17 04:00:00 PM"), ymd_hms("1996-05-17 16:00:00"))
expect_equal(ydm_hms("1996-17-05 04:00:00 PM"), ydm_hms("1996-17-05 16:00:00"))
expect_equal(dmy_hms("17-05-1996 04:00:00 PM"), dmy_hms("17-05-1996 16:00:00"))
expect_equal(
parse_date_time("2010-Dec-02 03:59:59 PM", "YmdT"),
parse_date_time2("2010-12-02 15:59:59", "YmdHMS")
)
expect_equal(
parse_date_time("2010-Dec-02 03:59:59 PM", "YmdT"),
parse_date_time2("2010-12-02 15:59:59", "YmdHMS")
)
expect_equal(
parse_date_time("2010-Dec-02 03:59 PM", "YmdR"),
parse_date_time2("2010-12-02 15:59:00", "YmdHMS")
)
expect_equal(
parse_date_time("2010-Dec-02 03 PM", "Ymdr"),
parse_date_time2("2010-12-02 15:00:00", "YmdHMS")
)
})
test_that("AM/PM is parsed correctly", {
raw <- c(
"09/17/2015 02:55:00 PM", "09/17/2015 04:22:00 PM", "09/17/2015 11:01:00 AM",
"09/17/2015 08:11:00 PM", "09/17/2015 03:00:00 PM", "09/17/2015 12:43:00 AM",
"09/17/2015 12:09:00 PM", "09/17/2015 04:57:00 PM", "09/17/2015 12:25:00 PM",
"09/17/2015 06:52:00 AM", "09/17/2015 11:08:00 AM", "09/17/2015 10:25:00 AM",
"09/17/2015 02:39:00 PM", "09/17/2015 10:28:00 AM", "09/17/2015 06:39:00 AM",
"09/17/2015 09:41:00 AM", "09/17/2015 09:12:00 AM", "09/17/2015 12:40:00 AM",
"09/17/2015 11:53:08 AM", "09/17/2015 04:40:30 PM", "09/17/2015 04:19:44 PM",
"09/17/2015 08:26:00 AM", "09/17/2015 02:32:17 PM", "09/17/2015 06:09:00 PM",
"09/17/2015 10:27:00 AM", "09/17/2015 12:59:00 PM", "09/17/2015 09:20:00 AM",
"09/17/2015 07:25:00 AM", "09/17/2015 05:49:04 AM", "09/17/2015 04:58:18 PM",
"09/17/2015 11:35:00 AM", "09/17/2015 10:21:48 AM", "09/17/2015 09:48:41 AM",
"09/17/2015 01:11:00 PM", "09/17/2015 08:52:00 AM", "09/17/2015 05:49:00 AM",
"09/17/2015 06:19:00 PM", "09/17/2015 10:17:19 AM", "09/17/2015 01:59:00 PM",
"09/17/2015 11:08:00 AM", "09/17/2015 03:37:59 AM", "09/16/2015 07:00:00 AM",
"09/17/2015 02:26:00 PM", "09/17/2015 10:58:00 AM", "09/17/2015 05:56:00 AM",
"09/17/2015 05:01:00 PM", "09/17/2015 10:15:00 AM", "09/17/2015 10:02:00 AM",
"09/17/2015 10:10:00 PM", "09/17/2015 12:56:00 PM", "09/17/2015 03:58:00 PM",
"09/17/2015 05:23:00 PM", "09/17/2015 12:20:00 PM", "09/17/2015 07:48:00 PM",
"09/17/2015 02:54:00 PM", "09/17/2015 10:02:00 PM", "09/17/2015 11:53:21 AM",
"09/17/2015 10:15:59 AM", "09/17/2015 08:22:00 AM", "09/17/2015 04:33:00 PM",
"09/17/2015 08:26:00 PM", "09/17/2015 08:01:00 AM", "09/17/2015 12:28:00 PM",
"09/17/2015 11:07:00 PM", "09/17/2015 11:09:00 PM", "09/17/2015 03:08:32 PM",
"09/17/2015 08:25:00 PM", "09/17/2015 01:45:00 PM", "09/17/2015 08:42:00 AM",
"09/17/2015 03:25:00 PM", "09/17/2015 09:32:00 AM", "09/17/2015 10:13:13 AM",
"09/17/2015 11:36:02 AM", "09/17/2015 03:23:00 PM", "09/17/2015 12:00:00 AM",
"09/17/2015 07:19:19 PM", "09/17/2015 08:59:06 AM", "09/17/2015 09:14:00 PM",
"09/17/2015 01:16:00 PM", "09/17/2015 08:54:35 AM", "09/17/2015 05:56:29 PM",
"09/17/2015 03:56:51 PM", "09/17/2015 09:52:22 AM", "09/17/2015 03:49:28 PM",
"09/17/2015 01:00:27 PM", "09/17/2015 09:52:32 PM", "09/17/2015 11:08:15 AM",
"09/17/2015 05:26:26 PM", "09/17/2015 04:53:56 PM", "09/02/2015 10:33:00 AM",
"09/17/2015 10:13:22 AM", "09/17/2015 12:50:00 PM", "09/17/2015 12:46:00 PM",
"09/02/2015 06:44:00 PM", "09/17/2015 02:21:06 PM", "09/17/2015 01:56:00 PM",
"09/17/2015 02:10:00 PM", "09/17/2015 05:43:28 AM", "09/17/2015 11:24:00 AM",
"09/17/2015 10:56:00 AM"
)
## dput(as.character(parse_date_time2(raw, "mdYHMSp")))
utc <- c(
"2015-09-17 14:55:00", "2015-09-17 16:22:00", "2015-09-17 11:01:00",
"2015-09-17 20:11:00", "2015-09-17 15:00:00", "2015-09-17 00:43:00",
"2015-09-17 12:09:00", "2015-09-17 16:57:00", "2015-09-17 12:25:00",
"2015-09-17 06:52:00", "2015-09-17 11:08:00", "2015-09-17 10:25:00",
"2015-09-17 14:39:00", "2015-09-17 10:28:00", "2015-09-17 06:39:00",
"2015-09-17 09:41:00", "2015-09-17 09:12:00", "2015-09-17 00:40:00",
"2015-09-17 11:53:08", "2015-09-17 16:40:30", "2015-09-17 16:19:44",
"2015-09-17 08:26:00", "2015-09-17 14:32:17", "2015-09-17 18:09:00",
"2015-09-17 10:27:00", "2015-09-17 12:59:00", "2015-09-17 09:20:00",
"2015-09-17 07:25:00", "2015-09-17 05:49:04", "2015-09-17 16:58:18",
"2015-09-17 11:35:00", "2015-09-17 10:21:48", "2015-09-17 09:48:41",
"2015-09-17 13:11:00", "2015-09-17 08:52:00", "2015-09-17 05:49:00",
"2015-09-17 18:19:00", "2015-09-17 10:17:19", "2015-09-17 13:59:00",
"2015-09-17 11:08:00", "2015-09-17 03:37:59", "2015-09-16 07:00:00",
"2015-09-17 14:26:00", "2015-09-17 10:58:00", "2015-09-17 05:56:00",
"2015-09-17 17:01:00", "2015-09-17 10:15:00", "2015-09-17 10:02:00",
"2015-09-17 22:10:00", "2015-09-17 12:56:00", "2015-09-17 15:58:00",
"2015-09-17 17:23:00", "2015-09-17 12:20:00", "2015-09-17 19:48:00",
"2015-09-17 14:54:00", "2015-09-17 22:02:00", "2015-09-17 11:53:21",
"2015-09-17 10:15:59", "2015-09-17 08:22:00", "2015-09-17 16:33:00",
"2015-09-17 20:26:00", "2015-09-17 08:01:00", "2015-09-17 12:28:00",
"2015-09-17 23:07:00", "2015-09-17 23:09:00", "2015-09-17 15:08:32",
"2015-09-17 20:25:00", "2015-09-17 13:45:00", "2015-09-17 08:42:00",
"2015-09-17 15:25:00", "2015-09-17 09:32:00", "2015-09-17 10:13:13",
"2015-09-17 11:36:02", "2015-09-17 15:23:00", "2015-09-17 00:00:00",
"2015-09-17 19:19:19", "2015-09-17 08:59:06", "2015-09-17 21:14:00",
"2015-09-17 13:16:00", "2015-09-17 08:54:35", "2015-09-17 17:56:29",
"2015-09-17 15:56:51", "2015-09-17 09:52:22", "2015-09-17 15:49:28",
"2015-09-17 13:00:27", "2015-09-17 21:52:32", "2015-09-17 11:08:15",
"2015-09-17 17:26:26", "2015-09-17 16:53:56", "2015-09-02 10:33:00",
"2015-09-17 10:13:22", "2015-09-17 12:50:00", "2015-09-17 12:46:00",
"2015-09-02 18:44:00", "2015-09-17 14:21:06", "2015-09-17 13:56:00",
"2015-09-17 14:10:00", "2015-09-17 05:43:28", "2015-09-17 11:24:00",
"2015-09-17 10:56:00"
)
tparse <- as.POSIXct(utc, tz = "UTC")
## DT(raw, tparse, R = parse_date_time(raw, "mdYT", locale = "C"))[, diff := R - tparse][diff != 0] %>% DF
expect_equal(mdy_hms(raw), tparse)
expect_equal(parse_date_time2(raw, "mdYHMSp"), tparse)
expect_equal(parse_date_time2(raw, "mdYHMSp"), tparse)
expect_equal(parse_date_time2(raw, "OmdYHMSOp"), tparse)
## this one ends in strptime
expect_equal(parse_date_time(raw, "mdYT", locale = "C"), tparse)
})
test_that("heterogeneous formats are correctly parsed", {
X <- c(20090101, "2009-01-02", "2009 01 03", "2009-1-4", "2009-1, 5", "2009....1--6", "200901-07", "200901-8")
Y <- c("2009-01-01", "2009-01-02", "2009-01-03", "2009-01-04", "2009-01-05", "2009-01-06", "2009-01-07", "2009-01-08")
expect_equal(ymd(X), as.Date(Y))
## cbind(ymd(X), as.POSIXct(Y, tz = "UTC"))
X <- c(
20100101120101, "2009-01-02 12-01-02", "2009.01.03 12:01:03",
"2009-1-4 12-1-4", "2009-1, 5 12:1, 5", "2009....1--6 - 12::1:6",
"20090107 120107", "2009-01-08 1201-08", "2010-01-09 12:01:09",
"2010-01-10 10:01:10 AM", "2010-01-11 10:01:11 PM"
)
Y <- c(
"2010-01-01 12:01:01", "2009-01-02 12:01:02", "2009-01-03 12:01:03",
"2009-01-04 12:01:04", "2009-01-05 12:01:05", "2009-01-06 12:01:06",
"2009-01-07 12:01:07", "2009-01-08 12:01:08", "2010-01-09 12:01:09",
"2010-01-10 10:01:10", "2010-01-11 22:01:11"
)
## cbind(as.character(ymd_hms(X)), as.character(as.POSIXct(Y, tz = "UTC")))
expect_equal(ymd_hms(X), as.POSIXct(Y, tz = "UTC"))
})
test_that("truncated formats are correctly parsed", {
x <- c("2011-12-31 12:59:59", "2010-01-01 12:11", "2010-01-01 12", "2010-01-01")
expect_equal(
{
ymd_hms(x, truncated = 3)
},
as.POSIXct(c(
"2011-12-31 12:59:59", "2010-01-01 12:11:00", "2010-01-01 12:00:00",
"2010-01-01 00:00:00"
), tz = "UTC")
)
x <- c("2011-12-31 12", "2010-01-01 12", "2010-01-01 12")
expect_equal(
ymd_h(x),
as.POSIXct(c(
"2011-12-31 12:00:00 UTC", "2010-01-01 12:00:00 UTC",
"2010-01-01 12:00:00 UTC"
), tz = "UTC")
)
x <- c("2011-12-31 12:01", "2010-01-01 12:02", "2010-01-01 12:03")
expect_equal(
ymd_hm(x),
as.POSIXct(c(
"2011-12-31 12:01:00 UTC", "2010-01-01 12:02:00 UTC",
"2010-01-01 12:03:00 UTC"
), tz = "UTC")
)
expect_equal(dmy_h("05-07-2011 13"), ymd_hms("2011-07-05 13:00:00"))
expect_equal(ymd_h("2011-07-05 13"), ymd_hms("2011-07-05 13:00:00"))
expect_equal(dmy_hm("05-07-2011 13:02"), ymd_hms("2011-07-05 13:02:00"))
expect_equal(ymd_hm("2011-07-05 13:02"), ymd_hms("2011-07-05 13:02:00"))
})
test_that("truncation on non-dates results in NAs indeed", {
expect_warning(
expect_true({
tt <- c("NI PODATKA", "TUJINA", "GRAD")
all(is.na(ymd_hms(tt, truncated = 3)))
})
)
})
test_that("missing months and days are allowed", {
expect_equal(parse_date_time2("2016", orders = "Y"), ymd("2016-01-01", tz = "UTC"))
expect_equal(parse_date_time2("2016-02", orders = "Ym"), ymd("2016-02-01", tz = "UTC"))
expect_equal(parse_date_time("2016", orders = "Y"), ymd("2016-01-01", tz = "UTC"))
expect_equal(parse_date_time("2016-02", orders = "Ym"), ymd("2016-02-01", tz = "UTC"))
expect_equal(parse_date_time(c("3:15:00"), c("IMS")), as.POSIXct("00-01-01 03:15:00", tz = "UTC"))
expect_equal(parse_date_time(c("3:15:00"), c("HMS")), as.POSIXct("00-01-01 03:15:00", tz = "UTC"))
expect_equal(parse_date_time(c("3:15:00 PM"), c("HMSp")), as.POSIXct("00-01-01 15:15:00", tz = "UTC"))
expect_equal(parse_date_time(c("3:15:00 PM"), c("IMSp")), as.POSIXct("00-01-01 15:15:00", tz = "UTC"))
})
test_that("fractional formats are correctly parsed", {
expect_equal(
{
x <- c("2011-12-31 12:59:59.23", "2010-01-01 12:11:10")
ymd_hms(x)
},
as.POSIXct(c("2011-12-31 12:59:59.23 UTC", "2010-01-01 12:11:10.00 UTC"), tz = "UTC")
)
expect_equal(hms("3:0:3.34"), hours(3) + minutes(0) + seconds(3.34))
})
test_that("hm correctly warns on un-parsed values", {
x <- c("05:00", "10:57", "10:58", "16:50", "21:59", NA)
expect_no_warning(hm(x))
x[3] <- ""
expect_warning(hm(x))
expect_silent(ymd(NA, "2001-01-01"))
expect_warning(ymd(NA, "2001-01-01 01"))
expect_true(is.na(ymd(NA, quiet = TRUE)))
expect_silent(ymd_hms(NA))
expect_true(is.na(ymd_hms(NA)))
expect_silent(ymd_hm(NA, "01-01-01 0:0"))
expect_warning(ymd_hm(NA, "01-01-01 0"))
expect_true(is.na(ymd_hm(NA, quiet = TRUE)))
expect_no_warning(hms(NA))
expect_true(is.na(hms(NA)))
expect_no_warning(ms(NA))
expect_true(is.na(ms(NA)))
})
test_that("Quarters are parsed correctly", {
qs <- c("2016.1", "2016:2", "2016-3", "2016 4", "2016.5")
out <- ymd(c("2016-01-01 UTC", "2016-04-01 UTC", "2016-07-01 UTC", "2016-10-01 UTC", NA), tz = "UTC")
expect_equal(parse_date_time2(qs, orders = "Yq"), out)
expect_equal(parse_date_time(qs, orders = "Yq", quiet = T), out)
expect_equal(yq(qs, tz = "UTC", quiet = T), out)
expect_equal(yq("16.1", "17.3", "2016.1"), ymd(c("2016-01-01", "2017-07-01", "2016-01-01")))
})
test_that("Year-months are parse correctly", {
yms <- c("2019-10", "2020-Oct", "2020 Oct", "2020 xyz")
out <- ymd("2019-10-01", "2020-Oct-01", "2020 Oct-01", NA)
expect_equal(out, ym(yms, quiet = TRUE))
mys <- c("10-2019", "Oct-2020", "Oct 2020", "xyz 2020")
out <- ymd("2019-10-01", "2020-Oct-01", "2020 Oct-01", NA)
expect_equal(out, my(mys, quiet = TRUE))
})
test_that("Vectors of NA's are parsed as vectors of NA's", {
mna <- as.POSIXct(as.POSIXlt(c(NA, NA, NA), tz = "UTC"))
pna <- new("Period",
.Data = c(NA_real_, NA_real_, NA_real_),
year = c(0, 0, 0),
month = c(0, 0, 0),
day = c(0, 0, 0),
hour = c(NA_real_, NA_real_, NA_real_),
minute = c(NA_real_, NA_real_, NA_real_)
)
pna2 <- new("Period",
.Data = c(NA_real_, NA_real_, NA_real_),
year = c(0, 0, 0),
month = c(0, 0, 0),
day = c(0, 0, 0),
hour = c(0, 0, 0),
minute = c(NA_real_, NA_real_, NA_real_)
)
expect_silent(ymd(NA, NA, NA))
expect_equal(ymd(NA, NA, NA, quiet = TRUE), as.Date(mna))
expect_silent(ymd_hms(NA, NA, NA))
expect_equal(ymd_hms(NA, NA, NA, quiet = TRUE), mna)
expect_silent(ymd_hm(NA, NA, NA))
expect_equal(ymd_hm(NA, NA, NA, quiet = TRUE), mna)
expect_no_warning(hms(NA, NA, NA))
expect_equal(hms(NA, NA, NA, quiet = TRUE), pna)
expect_no_warning(ms(NA, NA, NA))
expect_equal(ms(NA, NA, NA, quiet = TRUE), pna2)
expect_silent(ymd(c(NA, NA, NA)))
expect_equal(ymd(c(NA, NA, NA), quiet = TRUE), as.Date(mna))
expect_silent(ymd_hms(c(NA, NA, NA)))
expect_equal(ymd_hms(c(NA, NA, NA), quiet = TRUE), mna)
expect_silent(ymd_hm(c(NA, NA, NA)))
expect_equal(ymd_hm(c(NA, NA, NA), quiet = TRUE), mna)
expect_no_warning(hms(c(NA, NA, NA)))
expect_equal(hms(c(NA, NA, NA), quiet = TRUE), pna)
expect_no_warning(ms(c(NA, NA, NA)))
expect_equal(ms(c(NA, NA, NA), quiet = TRUE), pna2)
})
test_that("ISO8601: %z format (aka lubridate %Ou, %OO and %Oo formats) is correctly parsed", {
expect_equal(
parse_date_time("2012-12-04 15:06:06.95-0800", "YmdHMOSz"),
as.POSIXct("2012-12-04 23:06:06.95 UTC", tz = "UTC")
)
expect_equal(
parse_date_time(c("2012-12-04 15:06:06.95-08", "2012-12-04 15:06:06.95+08:00"), "YmdHMOSz"),
as.POSIXct(c("2012-12-04 23:06:06.95 UTC", "2012-12-04 07:06:06.95 UTC"), tz = "UTC")
)
expect_equal(
as.POSIXct(fast_strptime("2014-03-12T09:32:44Z", "%Y-%m-%dT%H:%M:%S%z")),
as.POSIXct("2014-03-12 09:32:44 UTC", tz = "UTC")
)
expect_equal(
as.POSIXct(fast_strptime("2014-03-12T09:32:44.33Z", "%Y-%m-%dT%H:%M:%OS%z")),
as.POSIXct("2014-03-12 09:32:44.33 UTC", tz = "UTC")
)
})
test_that("ISO8601: xxx_hms functions work correctly with z, Ou, OO and Oo formats.", {
expect_equal(
ymd_hms(c(
"2013-01-24 19:39:07.880-0600",
"2013-01-24 19:39:07.880", "2013-01-24 19:39:07.880-06:00",
"2013-01-24 19:39:07.880-06", "2013-01-24 19:39:07.880Z"
)),
as.POSIXct(c(
"2013-01-25 01:39:07.88 UTC",
"2013-01-24 19:39:07.88 UTC", "2013-01-25 01:39:07.88 UTC",
"2013-01-25 01:39:07.88 UTC", "2013-01-24 19:39:07.88 UTC"
), tz = "UTC")
)
})
test_that("ymd_hms treats time zones correctly", {
expect_equal(
ymd_hms("2012-03-03 23:06:07", tz = "America/Chicago"),
as.POSIXct("2012-03-03 23:06:07", tz = "America/Chicago")
)
})
test_that("ymd_hms parses Ou format correctly ", {
## Correct usage
expect_equal(
ymd_hms("2012-03-04T05:06:07Z"),
ymd_hms("2012-03-04 05:06:07", tz = "UTC")
)
expect_message(expect_equal(
ymd_hms("2012-03-04T05:06:07Z", tz = "America/Chicago"),
ymd_hms("2012-03-03 23:06:07", tz = "America/Chicago")
))
## check for message
expect_message(
ymd_hms("2012-03-04T05:06:07Z", tz = "America/Chicago"),
"Date in ISO8601 format"
)
})
test_that("ymd_hms parses OO and Oo formats correctly", {
## +00:00
expect_equal(
ymd_hms("2012-03-04T05:06:07+00:00"),
ymd_hms("2012-03-04 05:06:07", tz = "UTC")
)
## -HH
expect_equal(
ymd_hms("2012-03-04T05:06:07-01"),
ymd_hms("2012-03-04 06:06:07", tz = "UTC")
)
## -HHMM
expect_equal(
ymd_hms("2012-03-04T05:06:07-0130"),
ymd_hms("2012-03-04 06:36:07", tz = "UTC")
)
## -HH:MM
expect_equal(
ymd_hms("2012-03-04T05:06:07-01:30"),
ymd_hms("2012-03-04 06:36:07", tz = "UTC")
)
## +HH
expect_equal(
ymd_hms("2012-03-04T05:06:07+01"),
ymd_hms("2012-03-04 04:06:07", tz = "UTC")
)
## +HHMM
expect_equal(
ymd_hms("2012-03-04T05:06:07+0130"),
ymd_hms("2012-03-04 03:36:07", tz = "UTC")
)
## +HH:MM
expect_equal(
ymd_hms("2012-03-04T05:06:07+01:30"),
ymd_hms("2012-03-04 03:36:07", tz = "UTC")
)
## vectorizes
expect_equal(
ymd_hms(c("2012-03-04T05:06:07+01", "2012-03-04T05:06:07+01:30")),
ymd_hms(c("2012-03-04 04:06:07", "2012-03-04 03:36:07"), tz = "UTC")
)
expect_equal(
ymd_hms("2012-03-04T05:06:07-01:30", tz = "America/Chicago", quiet = T),
ymd_hms("2012-03-04 00:36:07", tz = "America/Chicago")
)
expect_message(
ymd_hms("2012-03-04T05:06:07-01:30", tz = "America/Chicago"),
"Date in ISO8601 format"
)
})
test_that("ymd parses mixed y an Y formats", {
## https://github.com/tidyverse/lubridate/issues/425
d3 <- c("6/25/15", "6/25/2015")
expect_equal(mdy(d3), as.Date(c("2015-06-25", "2015-06-25")))
d6 <- c("25/6/15", "25/6/2015")
expect_equal(dmy(d6), as.Date(c("2015-06-25", "2015-06-25")))
d9 <- c("15/6/25", "2015/6/25")
expect_equal(ymd(d9), as.Date(c("2015-06-25", "2015-06-25")))
})
test_that("ymd_hms parses mixed ISO-8601/non-ISO-8601 formats", {
suppressMessages(expect_equal(
ymd_hms(c("2012-03-04T05:06:07Z", "2001-02-03 04:05:06"), tz = "America/Chicago"),
ymd_hms(c("2012-03-03 23:06:07", "2001-02-03 04:05:06"), tz = "America/Chicago")
))
})
test_that("parse_date_time2 and fast_strptime parse ISO8601 timezones", {
tm <- "2001-02-03 11:22:33-0630"
ptm <- as.POSIXct("2001-02-03 17:52:33", tz = "UTC")
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%S%Oz")), ptm)
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%S%z")), ptm)
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%OS%Oz")), ptm)
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%OS%z")), ptm)
expect_equal(parse_date_time2(tm, "YmdHMSz"), ptm)
expect_equal(parse_date_time2(tm, "YmdHMSOz"), ptm)
expect_equal(parse_date_time2(tm, "YmdHMOSz"), ptm)
expect_equal(parse_date_time2(tm, "YmdHMOSOz"), ptm)
tm <- "2001-02-03 11:22:33-06:30"
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%OS%OO")), ptm)
expect_equal(as.POSIXct(fast_strptime(tm, "%Y-%m-%d %H:%M:%OS%z")), ptm)
expect_equal(parse_date_time2(tm, "YmdHMSz"), ptm)
expect_equal(parse_date_time2(tm, "YmdHMSOO"), ptm)
})
test_that("parse_date_time2 and fast_strptime correctly work with timezones", {
## https://github.com/tidyverse/lubridate/issues/394
expect_equal(
parse_date_time("12/03/16 12:00", "dmy HM", tz = "Europe/Zurich"),
parse_date_time2("12/03/16 12:00", "dmy HM", tz = "Europe/Zurich")
)
expect_equal(
as.POSIXct(strptime("12/03/16 12:00", "%d/%m/%y %H:%M", tz = "Europe/Zurich")),
parse_date_time2("12/03/16 12:00", "dmy HM", tz = "Europe/Zurich")
)
expect_equal(
as.POSIXct(strptime("12/03/16 12:00", "%d/%m/%y %H:%M", tz = "Europe/Zurich")),
as.POSIXct(fast_strptime("12/03/16 12:00", "%d/%m/%y %H:%M", tz = "Europe/Zurich"))
)
expect_equal(
as.POSIXct(strptime("12/03/16 12:00", "%d/%m/%y %H:%M", tz = "America/New_York")),
as.POSIXct(fast_strptime("12/03/16 12:00", "%d/%m/%y %H:%M", tz = "America/New_York"))
)
})
test_that("parse_date_time2 and fast_strptime correctly return lt objects", {
expect_s3_class(parse_date_time2("12/03/16 12:00", "dmy HM"), "POSIXct")
expect_s3_class(parse_date_time2("12/03/16 12:00", "dmy HM", lt = TRUE), "POSIXlt")
expect_s3_class(fast_strptime("12/03/16 12:00", "%d/%m/%y %H:%M"), "POSIXlt")
expect_s3_class(fast_strptime("12/03/16 12:00", "%d/%m/%y %H:%M", lt = FALSE), "POSIXct")
})
test_that("lt objects returned by parse_date_time2 and fast_strptime recycle the `isdst` field", {
## https://github.com/tidyverse/lubridate/issues/1044
x <- c("12/03/16 12:00", "12/03/16 14:00")
out <- parse_date_time2(x, "dmy HM", lt = TRUE)
expect_identical(unclass(out)[["isdst"]], c(-1L, -1L))
out <- fast_strptime(x, "%d/%m/%y %H:%M")
expect_identical(unclass(out)[["isdst"]], c(-1L, -1L))
})
test_that("ymd_hms, parse_date_time2, fast_strptime and base:strptime give the same result", {
## random times between 1400 and 3000
set.seed(1000)
X <- as.character(.POSIXct(runif(1000, -17987443200, 32503680000)))
oposix <- as.POSIXct(X, tz = "UTC")
opdt1 <- ymd_hms(X)
opdt2 <- parse_date_time2(X, "YmdHMOS")
ofstrptime <- as.POSIXct(fast_strptime(X, "%Y-%m-%d %H:%M:%OS"))
expect_equal(oposix, opdt1)
expect_equal(oposix, opdt2)
expect_equal(oposix, ofstrptime)
tzs <- strptime(X, "%Y-%m-%d %H:%M:%OS", tz = "America/New_York")
tzfs <- fast_strptime(X, "%Y-%m-%d %H:%M:%OS", tz = "America/New_York")
expect_equal(as.POSIXct(tzs), as.POSIXct(tzfs))
})
test_that("`parse_date_time2` parses formats with `exact=TRUE`", {
## https://github.com/tidyverse/lubridate/issues/326
expect_equal(
parse_date_time(c("12/17/1996 04:00:00"), "%m/%d/%Y %I:%M:%S", exact = T),
as.POSIXct(c("1996-12-17 04:00:00 UTC"), tz = "UTC")
)
expect_equal(
parse_date_time(c("021321", "021320"), c("%m%d%y"), exact = TRUE),
as.POSIXct(c("2021-02-13 00:00:00 UTC", "2020-02-13 00:00:00 UTC"),
tz = "UTC"
)
)
})
test_that("fast_strptime and parse_date_time2 parse correctly verbose formats", {
expect_equal(
as.POSIXct(fast_strptime("aa 2000 bbb10ccc 12 zzz", "aa %Y bbb%mccc %d zzz")),
as.POSIXct("2000-10-12", tz = "UTC")
)
expect_equal(
as.POSIXct(fast_strptime("aa 2000 5555 bbb10ccc 12 zzz", "aa %Y 5555 bbb%mccc %d zzz")),
as.POSIXct("2000-10-12", tz = "UTC")
)
expect_equal(
as.POSIXct(parse_date_time2("aa 2000 bbb10ccc 12 zzz", "Ymd")),
as.POSIXct("2000-10-12", tz = "UTC")
)
expect_equal(
as.POSIXct(parse_date_time2("aa 2000 5555 bbb10ccc 12 zzz", "Ymd")),
as.POSIXct(as.POSIXlt(NA, tz = "UTC"))
)
})
test_that("fast_strptime and parse_date_time2 deal correctly with leap years", {
expect_equal(
ymd(c("2000-02-29", "2100-02-29", "2400-02-29"), quiet = T),
as.Date(c("2000-02-29 UTC", NA, "2400-02-29 UTC"))
)
})
test_that("fast_strptime and parse_date_time2 detect excesive days", {
## https://github.com/tidyverse/lubridate/issues/#289
expect_equal(
ymd(c("2000-01-32", "2000-02-30", "2100-03-32", "2400-12-32"), quiet = T),
as.Date(c(NA, NA, NA, NA))
)
})
test_that("fast_strptime and parse_date_time2 aggree with strptime", {
date <- "1 7 97"
expect_equal(
as.POSIXct(fast_strptime(date, "%d %m %y")),
as.POSIXct(strptime(date, "%d %m %y", tz = "UTC"))
)
date <- "1 1 69"
expect_equal(
as.POSIXct(fast_strptime(date, "%d %m %y")),
as.POSIXct(strptime(date, "%d %m %y", tz = "UTC"))
)
date <- "1 1 68"
expect_equal(
as.POSIXct(fast_strptime(date, "%d %m %y")),
as.POSIXct(strptime(date, "%d %m %y", tz = "UTC"))
)
expect_equal(
as.POSIXct(parse_date_time2(date, "dmy")),
as.POSIXct(strptime(date, "%d %m %y", tz = "UTC"))
)
})
test_that("a and A formats are handled correctly (#254)", {
dates <- c("Saturday 31 August 2013", "Sun 12 Jan 2014")
expect_equal(
parse_date_time(x = dates, orders = c("dby")),
parse_date_time(x = dates, orders = c("adby"))
)
expect_equal(
parse_date_time(x = dates, orders = c("dby")),
parse_date_time(x = dates, orders = c("Adby"))
)
})
test_that("`parse_date_time` parses heterogeneous formats with `exact=TRUE`", {
## https://github.com/tidyverse/lubridate/issues/326
expect_equal(
parse_date_time(c("12/17/1996 04:00:00", "4/18/1950 0130"),
c("%m/%d/%Y %I:%M:%S", "%m/%d/%Y %H%M"),
exact = T
),
as.POSIXct(c("1996-12-17 04:00:00 UTC", "1950-04-18 01:30:00 UTC"), tz = "UTC")
)
x <- c("09-01-01", "090102", "09-01 03", "09-01-03 12:02")
expect_equal(
parse_date_time(x, c("%m-%d-%y", "%m%d%y", "%m-%d-%y %H:%M"), exact = TRUE, quiet = T),
as.POSIXct(c(
"2001-09-01 00:00:00 UTC", "2002-09-01 00:00:00 UTC",
NA, "2003-09-01 12:02:00 UTC"
),
tz = "UTC"
)
)
})
test_that("parser ignores case", {
ref <- ymd_hms("2016-01-04 07:40:00", "2016-01-04 07:40:00", "2016-01-04 07:40:00 UTC")
dts <- c("04jan2016:07:40:00", "04JAN2016:07:40:00", "04Jan2016:07:40:00")
expect_equal(ref, parse_date_time2(dts, "dBYHMS"))
expect_equal(ref, dmy_hms(dts))
})
test_that("parsing months with dots works in French linux locale", {
skip_on_cran()
skip_on_os(c("mac", "solaris", "windows"))
expect_equal(
parse_date_time("02 janv. 2015 12:48", "dbYHM", locale = "fr_FR.utf8"),
ymd_hms("2015-01-02 12:48:00 UTC")
)
expect_equal(
as.character(month(ymd(c("2015-01-01")) + months(1:3), locale = "fr_FR.utf8", label = T)),
c("févr", "mars", "avril")
)
})
test_that("parsing with j format works correctly", {
## https://github.com/tidyverse/lubridate/issues/1002
expect_equal(yday(parse_date_time(100, "j")), 100)
expect_equal(yday(parse_date_time(c(1, 150, 330), "j")), c(1, 150, 330))
})
test_that("parsing with r and R formats works in non-english locale", {
skip_on_cran()
suppressWarnings(testthat::skip_if(Sys.setlocale("LC_TIME", "fr_FR.utf8") == ""))
on.exit(Sys.setlocale("LC_TIME", "C"))
expect_equal(ymd_h("2021-10-26 0"), ymd("2021-10-26", tz = "UTC"))
expect_equal(ymd_hm("2022-11-05 12:00", tz = "GMT"), ymd_hms("2022-11-05 12:00:00", tz = "GMT"))
expect_equal(ymd_hm("2022-11-05 12:00", tz = "GMT"), ymd_hms("2022-11-05 12:00", tz = "GMT", truncated = 1))
expect_equal(dmy_hm("05-11-2022 12:00", tz = "GMT"), ymd_hms("2022-11-05 12:00", tz = "GMT", truncated = 1))
expect_equal(ymd_h("2021-10-26 0"), ymd("2021-10-26", tz = "UTC"))
expect_equal(parse_date_time("2021-10-26 0", "Ymdr"), ymd("2021-10-26", tz = "UTC"))
expect_equal(parse_date_time("2021-10-26 0001", "YmdR"), ymd_hms("2021-10-26 0:1:0"))
expect_equal(parse_date_time("2021-10-26 00 01", "YmdR"), ymd_hms("2021-10-26 0:1:0"))
})
test_that("NA_real_ propagates in parsing functions", {
expect_equal(ymd_hms(NA_real_), as_datetime(NA))
expect_equal(ymd_hms(c(20000101210101, NA_real_)), as_datetime(c("2000-01-01 21:01:01", NA)))
})
test_that("fractional qY dates are parsed correctly", {
## #1091
expect_equal(
parse_date_time(c(3.2007, 2.1970, 1.2020, 4.2009, 1.1975, NA), "qY"),
ymd(c("2007-07-01 UTC", "1970-04-01 UTC", "2020-01-01 UTC", "2009-10-01 UTC", "1975-01-01 UTC", NA), tz = "UTC"))
})
test_that("%a order parsers correctly", {
x <- c("Wed Apr 24 13:45:07 GMT-0500 2019", "Wednesday Apr 24 13:45:07 GMT-0500 2019")
y <- ymd_hms(c("2019-04-24 18:45:07", "2019-04-24 18:45:07"))
expect_equal(parse_date_time(x, "abdHMSzY"), y)
expect_equal(parse_date_time(x, "abdHMSzY"), y)
expect_equal(parse_date_time(x, "bdHMSzY"), y)
})
## library(microbenchmark)
## library(lubridate)
### PARSING
## options(digits.secs = 3)
## set.seed(100)
## tt <- as.character(.POSIXct(runif(1e6, -17987443200, 32503680000))) # random times between 1400 and 3000
## microbenchmark(#POSIXct = as.POSIXct(tt, tz = "UTC"),
## ymd_hms = ymd_hms(tt),
## pdt2 = parse_date_time2(tt, "YmdHMOS"),
## fstrptime = fast_strptime(tt, "%Y-%m-%d %H:%M:%OS", lt = FALSE),
## readr = parse_datetime(tt, "%Y-%m-%d %H:%M:%OS"),
## times = 10)
### MAKE DATETIMES
## N <- 1e4
## y <- as.integer(runif(N, 1800, 2200))
## m <- as.integer(runif(N, 1, 12))
## d <- as.integer(runif(N, 1, 28))
## H <- as.integer(runif(N, 0, 23))
## M <- as.integer(runif(N, 0, 59))
## S <- as.double(runif(N, 0, 59))
## ## S <- as.integer(S)
## microbenchmark(R = ISOdatetime(y, m, d, H, M, S, tz = "UTC"),
## L = make_datetime(y, m, d, H, M, S))
## system.time(out1 <- ISOdatetime(y, m, d, H, M, S, tz = "UTC"))
## system.time(out2 <- make_datetime(y, m, d, H, M, S))
## all.equal(out1, out2)
## table(out1 == out2)
## tt <- cbind(y, m, d, H, M, S, as.character(out1), as.character(out2), out1 == out2)
## tt <- cbind(y, m, d, H, M, S, out1, out2, out1 - out2, out1 == out2)
## head(tt, 40)
## cbind(out1, out2)[which(out1 != out2), ]
## all.equal(out, out1)
## all.equal(out, out2)
## all.equal(out, out3)
## this one is very slow
## system.time(out <- ymd_hms(tt, tz = "America/Chicago"))
## ttz <- paste(tt, "-0600", sep = "")
## system.time(out <- parse_date_time(ttz, "YmdHMOSz"))
## system.time(out <- ymd_hms(ttz))
## head(ttz)
## head(out)
## system.time(out2 <- parse_date_time2(ttz, "YmdHMOSz"))
## system.time(out2 <- parse_date_time2(ttz, "YmdHMOSOz"))
## system.time(out3 <- fast_strptime(ttz, "%Y-%m-%d %H:%M:%OS%z"))
## all.equal(out, out2)
## all.equal(out, out3)
## fast_strptime(tm, "%Y-%m-%d %H:%M:%S%z")
## fast_strptime("2893-04-08 22:54:37+0635", "%Y-%m-%d %H:%M:%S%Oz")
## system.time(out <- ymd_hms(ttz, tz = ""))
## stamp_OO <- stamp("2013-01-01T00:00:00-06:00")
## stamp_Ou <- stamp("2013-01-01T06:00:00Z")
## stamp_Oo <- stamp("2013-01-01T00:00:00-06")
## stamp_Oz <- stamp("2013-01-01T00:00:00-0600")
## stamp_OO <- stamp("2013-01-01T00:00:00-06:00")
## stamp_simple <- stamp("2013-01-01T00:00:00")
## system.time(out_st <- stamp_simple(out))
## system.time(out_st <- stamp_Ou(out))
## system.time(out_st <- stamp_OO(out))
## system.time(out_st <- stamp_OO(out))
## system.time(out_st <- stamp_Oz(out))
## tt <- rep(c(as.character(Sys.time()), as.character(Sys.Date())), 5e5)
## system.time(out <- as.POSIXct(tt, tz = "UTC"))
## system.time(out <- ymd_hms(tt, tz = "UTC", truncated = 3))
## Rprof()
## system.time(out <- as.POSIXct(strptime(tt, "%Y-%m-%d %H:%M:%S", tz = "UTC")))
## Rprof(NULL)
## Rprof()
## system.time(out <- ymd_hms(tt))
## Rprof(NULL)
## summaryRprof()
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.