Nothing
test_that("floor_date works as expected with POSIX units", {
set.seed(11111)
x <- ymd_hms(c("2020-01-03 00:01:03", "2020-02-04 00:01:03", "2020-03-05 00:00:00"), tz = "America/New_York")
min <- min(x)
b <- ymd_hms(c("2020-01-03 00:00:01", "2020-02-05 00:00:01"))
expect_equal(floor_date(x, b), b[c(1, 1, 2)])
expect_equal(floor_date(x, sample(b)), b[c(1, 1, 2)])
expect_equal(floor_date(x, rev(b)), b[c(1, 1, 2)])
expect_equal(floor_date(b, x), with_tz(c(b[1], x[2]), "America/New_York"))
expect_equal(floor_date(b, sample(x)), with_tz(c(b[1], x[2]), "America/New_York"))
expect_equal(floor_date(rev(b), x), with_tz(rev(c(b[1], x[2])), "America/New_York"))
expect_equal(floor_date(rev(x), b), rev(b[c(1, 1, 2)]))
expect_equal(floor_date(x, b[[2]]), c(with_tz(c(min, min), "UTC"), b[[2]]))
expect_equal(floor_date(ymd_hms("2030-01-01 00:03:00"), x), x[[3]])
expect_equal(floor_date(y <- ymd_hms("2010-01-01 00:03:00"), x), with_tz(y, "America/New_York"))
expect_equal(floor_date(ymd_hms("2030-01-01 00:03:00"), b), b[2])
})
test_that("floor_date works as expected with Date units", {
set.seed(11111)
x <- ymd(c("2020-01-03", "2020-02-04", "2020-03-05"))
min <- min(x)
b <- ymd(c("2020-01-03", "2020-02-05"))
expect_equal(floor_date(x, b), b[c(1, 1, 2)])
expect_equal(floor_date(x, sample(b)), b[c(1, 1, 2)])
expect_equal(floor_date(x, rev(b)), b[c(1, 1, 2)])
expect_equal(floor_date(b, x), c(b[1], x[2]))
expect_equal(floor_date(b, sample(x)), c(b[1], x[2]))
expect_equal(floor_date(rev(b), x), rev(c(b[1], x[2])))
expect_equal(floor_date(rev(x), b), rev(b[c(1, 1, 2)]))
expect_equal(floor_date(x, b[[2]]), c(c(min, min), b[[2]]))
expect_equal(floor_date(ymd("2030-01-01"), x), x[[3]])
expect_equal(floor_date(y <- ymd("2010-01-01"), x), y)
expect_equal(floor_date(ymd("2030-01-01"), b), b[2])
})
test_that("ceiling_date works as expected with POSIX units", {
set.seed(11111)
x <- ymd_hms(c("2020-01-03 00:01:03", "2020-02-04 00:01:03", "2020-03-05 00:00:00"), tz = "America/New_York")
na <- x
na[[2]] <- NA
max <- max(x)
b <- ymd_hms(c("2020-01-03 00:00:01", "2020-02-05 00:00:01"))
expect_equal(ceiling_date(x, b), c(b[c(2, 2)], max))
expect_equal(ceiling_date(na, b), c(b[2], NA, max))
expect_equal(ceiling_date(rev(x), b), rev(c(b[c(2, 2)], max)))
expect_equal(ceiling_date(x, sample(b)), c(b[c(2, 2)], max))
expect_equal(ceiling_date(x, rev(b)), c(b[c(2, 2)], max))
expect_equal(ceiling_date(b, x), x[c(1, 3)])
expect_equal(ceiling_date(b, sample(x)), x[c(1, 3)])
expect_equal(ceiling_date(rev(b), x), rev(x[c(1, 3)]))
expect_equal(ceiling_date(x, b[[2]]), c(b[c(2, 2)], max))
expect_equal(ceiling_date(y <- ymd_hms("2030-01-01 00:03:00"), x), with_tz(y, "America/New_York"))
expect_equal(ceiling_date(y <- ymd_hms("2010-01-01 00:03:00"), x), x[[1]])
})
test_that("ceiling_date works as expected with Date units", {
set.seed(11111)
x <- ymd(c("2020-01-04", "2020-02-04", "2020-03-05"))
na <- x
na[[2]] <- NA
max <- max(x)
b <- ymd(c("2020-01-03", "2020-02-05"))
expect_equal(ceiling_date(x, b), c(b[c(2, 2)], max))
expect_equal(ceiling_date(x, rep(b, 3)), c(b[c(2, 2)], max))
expect_equal(ceiling_date(na, b), c(b[2], NA, max))
expect_equal(ceiling_date(rev(x), b), rev(c(b[c(2, 2)], max)))
expect_equal(ceiling_date(x, sample(b)), c(b[c(2, 2)], max))
expect_equal(ceiling_date(x, rev(b)), c(b[c(2, 2)], max))
expect_equal(ceiling_date(b, x), x[c(1, 3)])
expect_equal(ceiling_date(b, sample(rep(x, 8))), x[c(1, 3)])
expect_equal(ceiling_date(rev(b), x), rev(x[c(1, 3)]))
expect_equal(ceiling_date(x, b[[2]]), c(b[c(2, 2)], max))
expect_equal(ceiling_date(y <- ymd("2030-01-01"), x), y)
expect_equal(ceiling_date(y <- ymd("2010-01-01"), x), x[[1]])
})
test_that("round_date works as expected with Date units", {
set.seed(11111)
x <- ymd(c("2020-01-04", "2020-02-04", "2020-03-05"))
na <- x
na[[2]] <- NA
max <- max(x)
b <- ymd(c("2020-01-03", "2020-02-05"))
expect_equal(round_date(x, b), b[c(1, 2, 2)])
expect_equal(round_date(na, b), c(b[1], NA, b[2]))
expect_equal(round_date(rev(x), b), b[c(2, 2, 1)])
expect_equal(round_date(x, sample(b)), b[c(1, 2, 2)])
expect_equal(round_date(x, rev(b)), b[c(1, 2, 2)])
expect_equal(round_date(x, rep(b, 10)), b[c(1, 2, 2)])
expect_equal(round_date(b, x), x[c(1, 2)])
expect_equal(round_date(b, sample(x)), x[c(1, 2)])
expect_equal(round_date(rev(b), x), rev(x[c(1, 2)]))
expect_equal(round_date(y <- ymd("2030-01-01"), x), x[3])
expect_equal(round_date(y <- ymd("2010-01-01"), x), x[1])
})
test_that("round_date works on POSIXlt objects", {
x <- as.POSIXlt(ymd_hms(c("2012-11-01 23:41:00", "2012-11-01 00:44:10"), tz = "America/New_York"))
expect_equal(
round_date(x, "5 mins"),
as.POSIXlt(ymd_hms(c("2012-11-01 23:40:00", "2012-11-01 00:45:00"), tz = "America/New_York"))
)
})
test_that("round_date fails with invalid date-time units", {
expect_error(round_date(now(), .POSIXct(double())), "Zero")
expect_error(floor_date(now(), .POSIXct(double())), "Zero")
expect_error(ceiling_date(now(), .POSIXct(double())), "Zero")
expect_error(round_date(now(), .POSIXct(NA_real_)), "NAs")
expect_error(floor_date(now(), .POSIXct(NA_real_)), "NAs")
expect_error(ceiling_date(now(), .POSIXct(NA_real_)), "NAs")
})
test_that("floor_date works for each time element", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_identical(floor_date(x, "second"), as.POSIXct("2009-08-03 12:01:59", tz = "UTC"))
expect_identical(floor_date(x, "minute"), as.POSIXct("2009-08-03 12:01:00", tz = "UTC"))
expect_identical(floor_date(x, "hour"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_identical(floor_date(x, "day"), as.POSIXct("2009-08-03 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "week"), as.POSIXct("2009-08-02 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "month"), as.POSIXct("2009-08-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "bimonth"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "quarter"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "halfyear"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "year"), as.POSIXct("2009-01-01 00:00:00", tz = "UTC"))
})
test_that("floor_date and round_date throw on invalid multi-unit spec", {
x <- ymd_hms("2009-08-03 12:01:57.11")
expect_error(floor_date(x, "120 sec"))
expect_error(floor_date(x, "120 min"))
expect_error(floor_date(x, "25 h"))
expect_error(floor_date(x, "32 days"))
})
test_that("floor_date works for multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_identical(floor_date(x, "2 secs"), as.POSIXct("2009-08-03 12:01:58", tz = "UTC"))
expect_identical(floor_date(x, "2s"), as.POSIXct("2009-08-03 12:01:58", tz = "UTC"))
expect_identical(floor_date(x, "2 mins"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2M"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2 hours"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2h"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2 days"), as.POSIXct("2009-08-03 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "3 days"), as.POSIXct("2009-08-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "10 days"), as.POSIXct("2009-08-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "10d"), as.POSIXct("2009-08-01 00:00:00", tz = "UTC"))
## expect_identical(floor_date(x, "2 week"), as.POSIXct("2009-08-xx 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2 month"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2m"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_identical(floor_date(x, "2 bimonth"), floor_date(x, "4 months"))
expect_identical(floor_date(x, "2 quarter"), floor_date(x, "6 months"))
expect_identical(floor_date(x, "2 halfyear"), floor_date(x, "year"))
expect_identical(floor_date(x, "2 year"), as.POSIXct("2008-01-01 00:00:00", tz = "UTC"))
})
test_that("floor_date works for fractional multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_identical(floor_date(x, ".2 secs"), as.POSIXct("2009-08-03 12:01:59.2", tz = "UTC"))
expect_identical(floor_date(x, ".1s"), as.POSIXct("2009-08-03 12:01:59.2", tz = "UTC"))
expect_identical(floor_date(x, ".05s"), as.POSIXct("2009-08-03 12:01:59.2", tz = "UTC"))
expect_identical(floor_date(x, ".01s"), as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC"))
expect_identical(floor_date(x, ".005s"), as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC"))
expect_identical(floor_date(x, ".5 mins"), as.POSIXct("2009-08-03 12:01:30", tz = "UTC"))
})
test_that("multi-unit rounding works the same for POSIX and Date objects", {
px <- ymd("2009-08-01", tz = "UTC")
dt <- ymd("2009-08-01")
expect_identical(floor_date(px, "5 mins"), floor_date(dt, "5 mins"))
expect_identical(floor_date(px, "5 mins"), floor_date(dt, "5 mins"))
expect_identical(ceiling_date(px + 0.0001, "5 mins"), ceiling_date(dt, "5 mins"))
expect_identical(
ceiling_date(px, "5 mins", change_on_boundary = T),
ceiling_date(dt, "5 mins", change_on_boundary = T)
)
expect_identical(ceiling_date(px + 0.001, "5 hours"), ceiling_date(dt, "5 hours"))
expect_identical(ceiling_date(px + 0.0001, "5 hours", change_on_boundary = T), ceiling_date(dt, "5 hours", change_on_boundary = T))
expect_identical(ceiling_date(px + 0.001, "2 hours"), ceiling_date(dt, "2 hours"))
expect_identical(as_date(floor_date(px, "2 days")), floor_date(dt, "2 days"))
expect_identical(as_date(ceiling_date(px + 0.001, "2 days")), ceiling_date(dt, "2 days"))
expect_identical(as_date(floor_date(px, "5 days")), floor_date(dt, "5 days"))
expect_identical(as_date(ceiling_date(px + 0.001, "5 days")), ceiling_date(dt, "5 days"))
expect_identical(as_date(floor_date(px, "2 months")), floor_date(dt, "2 months"))
expect_identical(as_date(ceiling_date(px, "2 months")), ceiling_date(dt, "2 months"))
expect_identical(as_date(floor_date(px, "5 months")), floor_date(dt, "5 months"))
expect_identical(as_date(ceiling_date(px, "5 months")), ceiling_date(dt, "5 months"))
})
test_that("ceiling_date works for multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
y <- as.POSIXct("2009-08-03 12:01:30.23", tz = "UTC")
z <- as.POSIXct("2009-08-24 12:01:30.23", tz = "UTC")
expect_identical(ceiling_date(x, "2 secs"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_identical(ceiling_date(x, "3 secs"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_identical(ceiling_date(x, "5 secs"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_identical(ceiling_date(y, "2 secs"), as.POSIXct("2009-08-03 12:01:32", tz = "UTC"))
expect_identical(ceiling_date(y, "3 secs"), as.POSIXct("2009-08-03 12:01:33", tz = "UTC"))
expect_identical(ceiling_date(y, "5 secs"), as.POSIXct("2009-08-03 12:01:35", tz = "UTC"))
expect_identical(ceiling_date(x, "2 mins"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_identical(ceiling_date(x, "3 mins"), as.POSIXct("2009-08-03 12:03:00", tz = "UTC"))
expect_identical(ceiling_date(x, "5 mins"), as.POSIXct("2009-08-03 12:05:00", tz = "UTC"))
expect_identical(ceiling_date(x, "2 hours"), as.POSIXct("2009-08-03 14:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "3 hours"), as.POSIXct("2009-08-03 15:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "2 days"), as.POSIXct("2009-08-05 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "3 days"), as.POSIXct("2009-08-04 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "10 days"), as.POSIXct("2009-08-11 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(z, "5 days"), as.POSIXct("2009-08-26 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(z, "10 days"), as.POSIXct("2009-08-31 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "2 month"), as.POSIXct("2009-09-01 00:00:00", tz = "UTC"))
expect_identical(ceiling_date(x, "2 bimonth"), ceiling_date(x, "4 months"))
expect_identical(ceiling_date(x, "2 quarter"), ceiling_date(x, "6 months"))
expect_identical(ceiling_date(x, "2 halfyear"), ceiling_date(x, "year"))
expect_identical(ceiling_date(x, "2 year"), as.POSIXct("2010-01-01 00:00:00", tz = "UTC"))
})
test_that("ceiling_date works for fractional multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_identical(ceiling_date(x, ".2 secs"), as.POSIXct("2009-08-03 12:01:59.4", tz = "UTC"))
expect_identical(ceiling_date(x, ".1s"), as.POSIXct("2009-08-03 12:01:59.3", tz = "UTC"))
expect_identical(ceiling_date(x, ".05s"), as.POSIXct("2009-08-03 12:01:59.25", tz = "UTC"))
expect_identical(ceiling_date(x, ".5 mins"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
})
test_that("round_date works for each time element", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_equal(round_date(x, "second"), as.POSIXct("2009-08-03 12:01:59", tz = "UTC"))
expect_equal(round_date(x, "minute"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_equal(round_date(x, "hour"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_equal(round_date(x, "day"), as.POSIXct("2009-08-04 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "week"), as.POSIXct("2009-08-02 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "month"), as.POSIXct("2009-08-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "bimonth"), as.POSIXct("2009-09-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "quarter"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "halfyear"), as.POSIXct("2009-07-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "year"), as.POSIXct("2010-01-01 00:00:00", tz = "UTC"))
})
test_that("floor_date and ceiling_date work with leap years", {
expect_equal(
floor_date(ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30")), "year"),
ymd_hms(c("2016-01-01 0:0:0", "2016-01-01 0:0:0"))
)
expect_equal(
floor_date(ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30"), tz = "America/New_York"), "year"),
ymd_hms(c("2016-01-01 0:0:0", "2016-01-01 0:0:0"), tz = "America/New_York")
)
expect_equal(
ceiling_date(ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30")), "year"),
ymd_hms(c("2017-01-01 0:0:0", "2017-01-01 0:0:0"))
)
expect_equal(
ceiling_date(ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30"), tz = "America/New_York"), "year"),
ymd_hms(c("2017-01-01 0:0:0", "2017-01-01 0:0:0"), tz = "America/New_York")
)
})
test_that("round_date works for multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_equal(round_date(x, "2 second"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_equal(round_date(x, "2 minute"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_equal(round_date(x, "3 mins"), as.POSIXct("2009-08-03 12:03:00", tz = "UTC"))
expect_equal(round_date(x, "5 mins"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_equal(round_date(x, "2 hour"), as.POSIXct("2009-08-03 12:00:00", tz = "UTC"))
expect_equal(round_date(x, "5 hour"), as.POSIXct("2009-08-03 10:00:00", tz = "UTC"))
expect_equal(round_date(x, "2 days"), as.POSIXct("2009-08-03 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "2 months"), as.POSIXct("2009-09-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "bimonth"), round_date(x, "2 months"))
expect_equal(round_date(x, "bimonth"), round_date(x, "4 months"))
expect_equal(round_date(x, "quarter"), round_date(x, "3 months"))
expect_equal(round_date(x, "halfyear"), round_date(x, "6 months"))
expect_equal(round_date(x, "3 years"), as.POSIXct("2010-01-01 00:00:00", tz = "UTC"))
expect_equal(round_date(x, "4 years"), as.POSIXct("2008-01-01 00:00:00", tz = "UTC"))
})
test_that("round_date works for fractional multi-units", {
x <- as.POSIXct("2009-08-03 12:01:59.23", tz = "UTC")
expect_identical(round_date(x, ".2 secs"), as.POSIXct("2009-08-03 12:01:59.2", tz = "UTC"))
expect_identical(round_date(x, ".1s"), as.POSIXct("2009-08-03 12:01:59.2", tz = "UTC"))
expect_identical(round_date(x, ".05s"), as.POSIXct("2009-08-03 12:01:59.25", tz = "UTC"))
expect_identical(round_date(x, ".5 mins"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
})
test_that("floor_date handles vectors", {
x <- as.POSIXct(c(
"2009-08-03 12:01:59.23",
"2010-08-03 12:01:59.23"
), tz = "UTC")
expect_identical(
floor_date(x, "second"),
as.POSIXct(c("2009-08-03 12:01:59", "2010-08-03 12:01:59"), tz = "UTC")
)
expect_identical(
floor_date(x, "minute"),
as.POSIXct(c("2009-08-03 12:01:00", "2010-08-03 12:01:00"), tz = "UTC")
)
expect_identical(
floor_date(x, "hour"),
as.POSIXct(c("2009-08-03 12:00:00", "2010-08-03 12:00:00"), tz = "UTC")
)
expect_identical(
floor_date(x, "day"),
as.POSIXct(c("2009-08-03 00:00:00", "2010-08-03 00:00:00"), tz = "UTC")
)
expect_identical(
floor_date(x, "week"),
as.POSIXct(c("2009-08-02 00:00:00", "2010-08-01 00:00:00"), tz = "UTC")
)
expect_identical(
floor_date(x, "month"),
as.POSIXct(c("2009-08-01 00:00:00", "2010-08-01 00:00:00"), tz = "UTC")
)
expect_identical(
floor_date(x, "year"),
as.POSIXct(c("2009-01-01 00:00:00", "2010-01-01 00:00:00"), tz = "UTC")
)
})
test_that("ceiling_date handles vectors", {
x <- as.POSIXct(c("2009-08-03 12:01:59.23", "2010-08-03 12:01:59.23"), tz = "UTC")
expect_identical(
ceiling_date(x, "second"),
as.POSIXct(c("2009-08-03 12:02:00", "2010-08-03 12:02:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "minute"),
as.POSIXct(c("2009-08-03 12:02:00", "2010-08-03 12:02:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "hour"),
as.POSIXct(c("2009-08-03 13:00:00", "2010-08-03 13:00:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "day"),
as.POSIXct(c("2009-08-04 00:00:00", "2010-08-04 00:00:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "week"),
as.POSIXct(c("2009-08-09 00:00:00", "2010-08-08 00:00:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "month"),
as.POSIXct(c("2009-09-01 00:00:00", "2010-09-01 00:00:00"), tz = "UTC")
)
expect_identical(
ceiling_date(x, "year"),
as.POSIXct(c("2010-01-01 00:00:00", "2011-01-01 00:00:00"), tz = "UTC")
)
})
test_that("round_date handles vectors", {
x <- as.POSIXct(c("2009-08-03 12:01:59.23", "2010-08-03 12:01:59.23"), tz = "UTC")
expect_identical(
round_date(x, "second"),
as.POSIXct(c(
"2009-08-03 12:01:59",
"2010-08-03 12:01:59"
), tz = "UTC")
)
expect_identical(
round_date(x, "minute"),
as.POSIXct(c(
"2009-08-03 12:02:00",
"2010-08-03 12:02:00"
), tz = "UTC")
)
expect_identical(
round_date(x, "hour"),
as.POSIXct(c(
"2009-08-03 12:00:00",
"2010-08-03 12:00:00"
), tz = "UTC")
)
expect_identical(
round_date(x, "day"),
as.POSIXct(c(
"2009-08-04 00:00:00",
"2010-08-04 00:00:00"
), tz = "UTC")
)
expect_identical(
round_date(x, "week"),
as.POSIXct(c(
"2009-08-02 00:00:00",
"2010-08-01 00:00:00"
), tz = "UTC")
)
expect_identical(
round_date(x, "month"),
as.POSIXct(c(
"2009-08-01 00:00:00",
"2010-08-01 00:00:00"
), tz = "UTC")
)
expect_identical(
round_date(x, "year"),
as.POSIXct(c(
"2010-01-01 00:00:00",
"2011-01-01 00:00:00"
), tz = "UTC")
)
})
test_that("floor_date works for a variety of formats", {
x <- as.POSIXct("2009-08-03 12:01:59", tz = "UTC")
expect_equal(
floor_date(x, "minute"),
as.POSIXct("2009-08-03 12:01:00", tz = "UTC")
)
expect_equal(
floor_date(as.Date(x), "month"),
as.Date("2009-08-01")
)
expect_equal(
floor_date(as.Date(x), "bimonth"),
ymd("2009-07-01")
)
expect_equal(
floor_date(as.Date(x), "quarter"),
ymd("2009-07-01")
)
expect_equal(
floor_date(as.Date(x), "halfyear"),
ymd("2009-07-01")
)
expect_equal(
floor_date(as.POSIXlt(x), "minute"),
as.POSIXlt(as.POSIXct("2009-08-03 12:01:00", tz = "UTC"))
)
})
test_that("ceiling_date works for a variety of formats", {
x <- as.POSIXct("2009-08-03 12:01:59", tz = "UTC")
expect_equal(
ceiling_date(x, "minute"),
as.POSIXct("2009-08-03 12:02:00", tz = "UTC")
)
expect_equal(
ceiling_date(as.Date(x), "month"),
as.Date("2009-09-01")
)
expect_equal(
ceiling_date(as.Date(x), "bimonth"),
ymd("2009-09-01")
)
expect_equal(
ceiling_date(as.Date(x), "quarter"),
ymd("2009-10-01")
)
expect_equal(
ceiling_date(as.Date(x), "halfyear"),
ymd("2010-01-01")
)
expect_equal(
ceiling_date(as.POSIXlt(x), "minute"),
as.POSIXlt(as.POSIXct("2009-08-03 12:02:00",
tz =
"UTC"
))
)
})
test_that("round_date works for a variety of formats", {
x <- as.POSIXct("2009-08-03 12:01:59", tz = "UTC")
expect_equal(round_date(x, "minute"), as.POSIXct("2009-08-03 12:02:00", tz = "UTC"))
expect_equal(round_date(as.Date(x), "month"), as.Date("2009-08-01"))
expect_equal(
# Workaround for https://github.com/r-lib/testthat/issues/1710
structure(round_date(as.POSIXlt(x), "minute"), balanced = NULL),
structure(as.POSIXlt(as.POSIXct("2009-08-03 12:02:00", tz = "UTC")), balanced = NULL))
## https://github.com/tidyverse/lubridate/issues/1008
y <- as.Date("2021-01-31")
expect_equal(round_date(y, "month"), as.Date("2021-02-01"))
})
test_that("rounding works across DST", {
## https://github.com/tidyverse/lubridate/issues/399
tt <- ymd("2016-03-27", tz = "Europe/Helsinki")
expect_equal(ceiling_date(tt, "month"), as.POSIXct("2016-04-01", tz = "Europe/Helsinki"))
expect_equal(ceiling_date(tt, "day"), as.POSIXct("2016-03-27", tz = "Europe/Helsinki"))
tt <- ymd("2016-03-28", tz = "Europe/Helsinki")
expect_equal(floor_date(tt, "month"), as.POSIXct("2016-03-01", tz = "Europe/Helsinki"))
tt <- ymd_hms("2016-03-27 05:00:00", tz = "Europe/Helsinki")
expect_equal(floor_date(tt, "day"), as.POSIXct("2016-03-27", tz = "Europe/Helsinki"))
## https://github.com/tidyverse/lubridate/issues/605
x <- ymd_hms("2017-11-05 23:59:03", tz = "America/New_York")
expect_equal(ceiling_date(x, "day"), as.POSIXct("2017-11-06", tz = "America/New_York"))
})
test_that("Ceiling for partials (Date) rounds up on boundary", {
expect_identical(ceiling_date(as.Date("2012-09-27"), "day"), ymd("2012-09-28"))
expect_identical(ceiling_date(as.Date("2012-09-01"), "day"), ymd("2012-09-02"))
expect_identical(ceiling_date(as.Date("2012-09-01"), "2 days"), ymd("2012-09-03"))
})
test_that("Ceiling for Date returns date when unit level is higher than day", {
expect_true(is.Date(ceiling_date(ymd("20160927"), "year")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "halfyear")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "quarter")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "bimonth")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "month")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "week")))
expect_true(is.Date(ceiling_date(ymd("20160927"), "day")))
expect_true(is.POSIXct(ceiling_date(ymd("20160927"), "hour")))
expect_true(is.POSIXct(ceiling_date(ymd("20160927"), "minute")))
expect_true(is.POSIXct(ceiling_date(ymd("20160927"), "second")))
})
test_that("Ceiling for POSIXct always returns POSIXct", {
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "year")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "halfyear")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "quarter")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "bimonth")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "month")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "week")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "day")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "hour")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "minute")))
expect_true(is.POSIXct(ceiling_date(ymd_hms("20160927 00:00:00"), "second")))
})
test_that("ceiling_date does not round up dates that are already on a boundary", {
expect_equal(ceiling_date(ymd_hms("2012-09-01 00:00:00"), "month"), as.POSIXct("2012-09-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "year"), as.POSIXct("2012-01-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "2 year"), as.POSIXct("2012-01-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "3 year"), as.POSIXct("2013-01-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "5 year"), as.POSIXct("2015-01-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 01:00:00"), "second"), ymd_hms("2012-01-01 01:00:00"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 01:00:00"), "2 second"), ymd_hms("2012-01-01 01:00:00"))
expect_equal(
ceiling_date(ymd_hms("2012-01-01 01:00:00"), "2 second", change_on_boundary = T),
ymd_hms("2012-01-01 01:00:02")
)
expect_equal(ceiling_date(ymd_hms("2012-01-01 01:00:00"), "5 second"), ymd_hms("2012-01-01 01:00:00"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "bimonth"), ymd_hms("2012-01-01 00:00:00"))
})
test_that("ceiling_date does round up dates on a boundary with change_on_boundary=TRUE", {
expect_equal(ceiling_date(as.Date("2012-09-27"), "day", TRUE), as.Date("2012-09-28"))
expect_equal(ceiling_date(as.Date("2012-09-01"), "month", TRUE), as.Date("2012-10-01"))
expect_equal(ceiling_date(ymd_hms("2012-09-01 00:00:00"), "month", TRUE), ymd("2012-10-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-09-01 00:00:00"), "bimonth", TRUE), ymd("2012-11-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "year", TRUE), as.POSIXct("2013-01-01", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 01:00:00"), "hour", TRUE), ymd_hms("2012-01-01 02:00:00"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 00:00:00"), "day", TRUE), ymd("2012-01-02", tz = "UTC"))
expect_equal(ceiling_date(ymd_hms("2012-01-01 01:00:00"), "second", TRUE), ymd_hms("2012-01-01 01:00:01"))
})
test_that("floor_date does not round down dates that are already on a boundary", {
expect_equal(floor_date(as.Date("2012-09-27"), "day"), as.Date("2012-09-27"))
})
test_that("round_date does not round dates that are already on a boundary", {
expect_equal(round_date(as.Date("2012-09-27"), "day"), as.Date("2012-09-27"))
})
test_that("ceiling_date returns input of length zero when given input of length zero", {
x <- structure(vector(mode = "numeric"), class = c("POSIXct", "POSIXt"))
expect_equal(ceiling_date(x), x)
})
test_that("floor_date returns input of length zero when given input of length zero", {
x <- structure(vector(mode = "numeric"), class = c("POSIXct", "POSIXt"))
expect_equal(floor_date(x), x)
})
test_that("round_date returns input of length zero when given input of length zero", {
x <- structure(vector(mode = "numeric"), class = c("POSIXct", "POSIXt"))
expect_equal(round_date(x), x)
})
test_that("round_date behaves correctly on 60th second", {
## (bug #217)
x <- ymd_hms("2013-12-01 23:59:59.9999")
expect_equal(
round_date(x, unit = "second"),
ymd("2013-12-02", tz = "UTC")
)
second(x) <- 60
expect_equal(x, ymd("2013-12-02", tz = "UTC"))
})
test_that("round_date and ceiling_date skip day time gap", {
## (#240)
tz <- "Europe/Amsterdam"
times <- ymd_hms("2013-03-31 01:00:00 CET", "2013-03-31 01:15:00 CEST",
"2013-03-31 01:30:00 CEST", "2013-03-31 01:45:00 CEST",
"2013-03-31 03:00:00 CEST", "2013-03-31 03:15:00 CEST",
tz = tz
)
round <- ymd_hms("2013-03-31 01:00:00 CET",
"2013-03-31 01:00:00 CEST", "2013-03-31 03:00:00 CEST",
"2013-03-31 03:00:00 CEST", "2013-03-31 03:00:00 CEST",
"2013-03-31 03:00:00 CEST",
tz = tz
)
expect_equal(round_date(times, "hour"), round)
ceiling <- ymd_hms("2013-03-31 01:00:00 CET",
"2013-03-31 03:00:00 CEST", "2013-03-31 03:00:00 CEST",
"2013-03-31 03:00:00 CEST", "2013-03-31 03:00:00 CEST",
"2013-03-31 04:00:00 CEST",
tz = tz
)
expect_equal(ceiling_date(times, "hour"), ceiling)
tz <- "America/Chicago"
x <- ymd_hms(c(
"2014-03-09 00:00:00", "2014-03-09 00:29:59", "2014-03-09 00:30:00",
"2014-03-09 00:59:59", "2014-03-09 01:35:00", "2014-03-09 03:15:00",
"2014-11-02 00:30:00", "2014-11-02 00:59:59", "2014-11-02 01:35:00",
"2014-11-02 02:15:00", "2014-11-02 02:45:00"
),
tz = tz
)
y <- as.POSIXct(c(
"2014-03-09 00:00:00", "2014-03-09 00:00:00", "2014-03-09 01:00:00",
"2014-03-09 01:00:00", "2014-03-09 03:00:00", "2014-03-09 03:00:00",
"2014-11-02 01:00:00", "2014-11-02 01:00:00", "2014-11-02 02:00:00",
"2014-11-02 02:00:00", "2014-11-02 03:00:00"
),
tz = tz
)
## ymd_hms("2014-11-02 01:35:00", tz = tz)
## force_tz(ymd_hms("2014-11-02 01:35:00"), tzone = "America/Chicago")
## round_date(ymd_hms("2014-11-02 01:35:00", tz = "America/Chicago"), "hour")
expect_equal(round_date(x, "hour"), y)
})
test_that("rounding works within repeated DST", {
## "2014-11-02 00:00:00 CDT"
ref <- ymd_hms("2014-11-02 00:00:00", tz = "America/Chicago")
expect_equal(round_date(ref + dminutes(25), "hour"), ref)
expect_equal(round_date(ref + dminutes(35), "hour"), ref + dhours(1))
expect_equal(round_date(ref + dhours(1) + dminutes(25), "hour"), ref + dhours(1))
expect_equal(round_date(ref + dhours(1) + dminutes(35), "ahour"), ref + dhours(2))
expect_equal(round_date(ref + dhours(2) + dminutes(20), "hour"), ref + dhours(2))
expect_equal(round_date(ref + dhours(2) + dminutes(35), "hour"), ref + dhours(3))
expect_equal(round_date(ref + duration("1H 35M 2S"), "minute"), ref + duration("1H 35M"))
expect_equal(round_date(ref + duration("1H 35M 35S"), "minute"), ref + duration("1H 36M"))
expect_equal(round_date(ref + duration("2H 35M 2S"), "minute"), ref + duration("2H 35M"))
})
test_that("ceiling_date, round_date and floor_date behave correctly with NA", {
## (bug #486)
x <- ymd_hms("2009-08-03 12:01:59.23", tz = "UTC") + (0:1) * days()
x[2] <- NA
expect_equal(ceiling_date(x, unit = "day"), ymd(c("2009-08-04", NA), tz = "UTC"))
expect_equal(ceiling_date(x, unit = "seconds"), ymd_hms(c("2009-08-03 12:02:00", NA), tz = "UTC"))
expect_equal(ceiling_date(x, unit = "months"), ymd(c("2009-09-01", NA), tz = "UTC"))
expect_equal(floor_date(x, unit = "day"), ymd(c("2009-08-03", NA), tz = "UTC"))
expect_equal(floor_date(x, unit = "months"), ymd(c("2009-08-01", NA), tz = "UTC"))
expect_equal(round_date(x, unit = "minute"), ymd_hms(c("2009-08-03 12:02:00", NA), tz = "UTC"))
})
test_that("floor_date works for seasons", {
dts <- ymd_hms(sprintf("2017-%d-02 0:34:3", 1:12))
expect_equal(month(floor_date(dts, "season")), c(12, 12, 3, 3, 3, 6, 6, 6, 9, 9, 9, 12))
dts <- force_tz(dts, "America/New_York")
expect_equal(month(floor_date(dts, "season")), c(12, 12, 3, 3, 3, 6, 6, 6, 9, 9, 9, 12))
})
test_that("ceiling_date works for seasons", {
dts <- ymd_hms(sprintf("2017-%d-02 0:34:3", 1:12))
expect_equal(month(ceiling_date(dts, "season")), c(3, 3, 6, 6, 6, 9, 9, 9, 12, 12, 12, 3))
dts <- force_tz(dts, "America/New_York")
expect_equal(month(ceiling_date(dts, "season")), c(3, 3, 6, 6, 6, 9, 9, 9, 12, 12, 12, 3))
})
test_that("round on week respects week_start", {
date <- ymd("2017-05-07") ## sunday
ct <- as.POSIXct("2010-02-03 13:45:59", tz = "America/New_York", format = "%Y-%m-%d %H:%M:%S") ## Wednesday
expect_equal(wday(floor_date(ct, "week", week_start = 1)), 2)
expect_equal(wday(floor_date(ct, "week", week_start = 2)), 3)
expect_equal(wday(floor_date(ct, "week", week_start = 5)), 6)
expect_equal(wday(floor_date(ct, "week", week_start = 7)), 1)
expect_equal(wday(floor_date(date, "week", week_start = 1)), 2)
expect_equal(wday(floor_date(date, "week", week_start = 2)), 3)
expect_equal(wday(floor_date(date, "week", week_start = 5)), 6)
expect_equal(wday(floor_date(date, "week", week_start = 7)), 1)
expect_equal(wday(floor_date(ct, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(floor_date(ct, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(floor_date(ct, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(floor_date(ct, "week", week_start = 7), week_start = 7), 1)
expect_equal(wday(floor_date(date, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(floor_date(date, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(floor_date(date, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(floor_date(date, "week", week_start = 7), week_start = 7), 1)
expect_equal(wday(ceiling_date(ct, "week", week_start = 1)), 2)
expect_equal(wday(ceiling_date(ct, "week", week_start = 2)), 3)
expect_equal(wday(ceiling_date(ct, "week", week_start = 5)), 6)
expect_equal(wday(ceiling_date(ct, "week", week_start = 7)), 1)
expect_equal(wday(ceiling_date(date, "week", week_start = 1)), 2)
expect_equal(wday(ceiling_date(date, "week", week_start = 2)), 3)
expect_equal(wday(ceiling_date(date, "week", week_start = 5)), 6)
expect_equal(wday(ceiling_date(date, "week", week_start = 7)), 1)
expect_equal(wday(ceiling_date(ct, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(ceiling_date(ct, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(ceiling_date(ct, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(ceiling_date(ct, "week", week_start = 7), week_start = 7), 1)
expect_equal(wday(ceiling_date(date, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(ceiling_date(date, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(ceiling_date(date, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(ceiling_date(date, "week", week_start = 7), week_start = 7), 1)
expect_equal(wday(round_date(ct, "week", week_start = 1)), 2)
expect_equal(wday(round_date(ct, "week", week_start = 2)), 3)
expect_equal(wday(round_date(ct, "week", week_start = 5)), 6)
expect_equal(wday(round_date(ct, "week", week_start = 7)), 1)
expect_equal(wday(round_date(date, "week", week_start = 1)), 2)
expect_equal(wday(round_date(date, "week", week_start = 2)), 3)
expect_equal(wday(round_date(date, "week", week_start = 5)), 6)
expect_equal(wday(round_date(date, "week", week_start = 7)), 1)
expect_equal(wday(round_date(ct, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(round_date(ct, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(round_date(ct, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(round_date(ct, "week", week_start = 7), week_start = 7), 1)
expect_equal(wday(round_date(date, "week", week_start = 1), week_start = 1), 1)
expect_equal(wday(round_date(date, "week", week_start = 2), week_start = 2), 1)
expect_equal(wday(round_date(date, "week", week_start = 5), week_start = 5), 1)
expect_equal(wday(round_date(date, "week", week_start = 7), week_start = 7), 1)
})
test_that("rounding works when week_start = name of week day", {
date <- ymd("2017-05-07") ## sunday
ct <- as.POSIXct("2010-02-03 13:45:59", tz = "America/New_York", format = "%Y-%m-%d %H:%M:%S") ## Wednesday
expect_identical(floor_date(ct, "week", week_start = "Monday"), floor_date(ct, "week", week_start = 1))
expect_identical(floor_date(ct, "week", week_start = "Tuesday"), floor_date(ct, "week", week_start = 2))
expect_identical(ceiling_date(ct, "week", week_start = "Monday"), ceiling_date(ct, "week", week_start = 1))
expect_identical(ceiling_date(ct, "week", week_start = "Friday"), ceiling_date(ct, "week", week_start = 5))
expect_identical(ceiling_date(ct, "week", week_start = "Mond"), ceiling_date(ct, "week", week_start = 1))
expect_identical(ceiling_date(ct, "week", week_start = "Fri"), ceiling_date(ct, "week", week_start = 5))
expect_identical(round_date(ct, "week", week_start = "Monday"), round_date(ct, "week", week_start = 1))
expect_identical(round_date(ct, "week", week_start = "Sunday"), round_date(ct, "week", week_start = 7))
expect_identical(round_date(ct, "week", week_start = "Mon"), round_date(ct, "week", week_start = 1))
expect_identical(round_date(ct, "week", week_start = "Sund"), round_date(ct, "week", week_start = 7))
})
test_that("wday extract and update: week_start can be a week day", {
d <- ymd("2017-01-02") # Monday
p <- as_datetime(d)
expect_identical(wday(d, week_start = "Tue"), 7)
expect_identical(wday(p, week_start = "Tue"), 7)
expect_identical(wday(d, week_start = "Monday"), 1)
expect_identical(wday(p, week_start = "Monday"), 1)
expect_identical(wday(2, week_start = "Monday"), 1)
expect_identical(wday(2, week_start = "Monday"), wday(2, week_start = 1))
wday(d) <- "Tue"
expect_identical(wday(d), 3)
# ignore week_start when value is a character
wday(d, week_start = 1) <- "Tue"
expect_identical(wday(d), 3)
wday(p, week_start = 2) <- "Sunday"
expect_identical(wday(p), 1)
wday(p) <- "Wednesday"
expect_identical(wday(p), 4)
wday(d) <- 4
expect_identical(wday(d), 4)
wday(d, week_start = 2) <- 4
expect_identical(wday(d, week_start = 2), 4)
wday(p) <- 5
expect_identical(wday(p), 5)
})
test_that("rounding works for dates < 1970", {
expect_equal(round_date(ymd_hms("1957-12-01 14:00:00 UTC"), "month"),
ymd("1957-12-01", tz = "UTC"))
expect_equal(round_date(ymd_hms("1958-01-31 09:59:59 UTC"), "month"),
ymd("1958-02-01", tz = "UTC"))
})
test_that("rounding of fractional second works around origin", {
## #789
seq <- seq(0, 500, 33)/1000
time <- lubridate::origin - seq
rnd <- round_date(time, ".033s")
expect_true(all(unclass(rnd) > -.52))
time <- lubridate::origin + seq
rnd <- round_date(time, ".033s")
expect_true(all(unclass(rnd) < .5))
## plot(time, rnd)
})
test_that("ceiling of dates works correctly before 1970", {
#1107
dates <- ymd('1969-01-01') + years(c(0:2))
expect_equal(ceiling_date(dates, 'month', change_on_boundary = FALSE), dates)
expect_equal(ceiling_date(dates, unit = 'month', change_on_boundary = TRUE), dates + months(1))
})
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.