test_that("addition handles daylight savings time", {
x <- as.POSIXct("2010-03-14 00:00:00", tz = "America/New_York")
y <- as.POSIXct("2010-03-15 01:00:00", tz = "America/New_York")
expect_equal(x + days(1), as.POSIXct(
"2010-03-15 00:00:00",
tz = "America/New_York"
))
expect_equal(x + ddays(1), y)
})
test_that("subtraction handles daylight savings time", {
x <- as.POSIXct("2010-03-15 00:00:00", tz = "America/New_York")
y <- as.POSIXct("2010-03-13 23:00:00", tz = "America/New_York")
expect_equal(x - days(1), as.POSIXct(
"2010-03-14 00:00:00",
tz = "America/New_York"
))
expect_equal(x - ddays(1), y)
})
test_that("addition works as expected for instants", {
x <- as.POSIXct("2008-01-01 00:00:00", tz = "UTC")
y <- as.POSIXlt("2008-01-01 00:00:00", tz = "UTC")
z <- as.Date("2008-01-01")
expect_equal(x + years(1), as.POSIXct("2009-01-01 00:00:00", tz = "UTC"))
expect_equal(y + years(1), as.POSIXlt("2009-01-01 00:00:00", tz = "UTC"))
expect_equal(z + years(1), as.Date("2009-01-01"))
expect_equal(x + dyears(1), as.POSIXct("2008-12-31 06:00:00", tz = "UTC"))
expect_equal(y + dyears(1), as.POSIXlt("2008-12-31 06:00:00", tz = "UTC"))
expect_equal(z + dyears(1), as.POSIXct("2008-12-31 06:00:00", tz = "UTC"))
time1 <- as.POSIXct("2008-08-02 13:01:59", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 13:01:59", tz = "UTC")
int <- interval(time1, time2)
num <- as.numeric(time2) - as.numeric(time1)
expect_error(x + int)
expect_error(y + int)
expect_error(z + int)
})
test_that("addition with instants returns correct class", {
x <- as.POSIXct("2008-01-02 00:00:00", tz = "UTC")
y <- as.POSIXlt("2008-01-02 00:00:00", tz = "UTC")
z <- as.Date("2008-01-01")
expect_s3_class(x + years(1), "POSIXct")
expect_s3_class(y + years(1), "POSIXlt")
expect_s3_class(z + years(1), "Date")
expect_s3_class(x + dyears(1), "POSIXct")
expect_s3_class(y + dyears(1), "POSIXlt")
expect_s3_class(z + dyears(1), "POSIXct")
})
test_that("addition works as expected for periods", {
time1 <- as.POSIXct("2008-01-02 00:00:00", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 00:00:00", tz = "UTC")
int <- interval(time1, time2)
expect_equal(years(1) + 1, period(seconds = 1, years = 1))
expect_equal(
years(1) + as.POSIXct("2008-01-01 00:00:00", tz = "UTC"),
as.POSIXct("2009-01-01 00:00:00", tz = "UTC")
)
expect_equal(
years(1) + as.POSIXlt("2008-01-01 00:00:00", tz = "UTC"),
as.POSIXlt("2009-01-01 00:00:00", tz = "UTC")
)
expect_equal(years(1) + minutes(3), period(
minutes = 3,
years = 1
))
expect_error(years(1) + dyears(1))
expect_error(years(1) + int)
})
test_that("addition with periods returns correct class", {
expect_s4_class(years(1) + 1, "Period")
expect_s3_class(years(1) + as.POSIXct(
"2008-01-01 00:00:00",
tz = "UTC"
), "POSIXt")
expect_s3_class(years(1) + as.POSIXlt(
"2008-01-01 00:00:00",
tz = "UTC"
), "POSIXlt")
expect_s4_class(years(1) + minutes(3), "Period")
})
test_that("addition works as expected for durations", {
x <- as.POSIXct("2008-01-01 00:00:00", tz = "UTC")
y <- as.POSIXct("2008-12-31 06:00:00", tz = "UTC")
time1 <- as.POSIXct("2008-01-02 00:00:00", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 00:00:00", tz = "UTC")
int <- interval(time1, time2)
expect_equal(dyears(1) + 1, duration(31557601))
expect_equal(dyears(1) + x, y)
expect_equal(dyears(1) + dyears(1), dyears(2))
expect_error(dyears(1) + minutes(3))
expect_error(dyears(1) + int)
})
test_that("addition with durations returns correct class", {
ct <- as.POSIXct("2008-01-01 00:00:00", tz = "UTC")
lt <- as.POSIXlt("2008-01-01 00:00:00", tz = "UTC")
expect_s4_class(dyears(1) + 1, "Duration")
expect_s3_class(dyears(1) + ct, "POSIXct")
expect_s3_class(dyears(1) + lt, "POSIXlt")
expect_s4_class(dyears(1) + dyears(1), "Duration")
})
test_that("addition works as expected for intervals", {
time1 <- as.POSIXct("2008-08-03 13:01:59", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 13:01:59", tz = "UTC")
time3 <- as.POSIXct("2008-01-01 00:00:00", tz = "UTC")
diff <- difftime(time2, time1)
int <- interval(time1, time2)
expect_error(int + time3)
expect_error(int + time1)
expect_error(int + 1)
expect_error(int + minutes(3))
expect_error(int + dyears(1))
time5 <- as.POSIXct("2010-08-03 00:00:00", tz = "UTC")
int3 <- interval(time2, time5)
expect_error(int + int3)
})
#### Vectors
test_that("adding vectors works as expected for instants", {
x <- as.POSIXct(c("2008-01-01 00:00:00", "2009-01-01 00:00:00"), tz = "UTC")
y <- as.POSIXlt(c("2008-01-01 00:00:00", "2009-01-01 00:00:00"), tz = "UTC")
z <- c(as.Date("2008-01-01"), as.Date("2008-01-10"))
expect_equal(x + years(1), ymd_hms(c("2009-01-01 00:00:00", "2010-01-01 00:00:00")))
expect_equal(y + years(1), as.POSIXlt(c("2009-01-01 00:00:00", "2010-01-01 00:00:00"), tz = "UTC"))
expect_equal(z + years(1), as.Date(c("2009-01-01", "2009-01-10")))
expect_equal(x + dyears(1), ymd_hms(c("2008-12-31 06:00:00", "2010-01-01 06:00:00")))
expect_equal(y + dyears(1), as.POSIXlt(c("2008-12-31 06:00:00", "2010-01-01 06:00:00"), tz = "UTC"))
expect_equal(z + dyears(1), ymd_hms(c("2008-12-31 06:00:00", "2009-01-09 06:00:00")))
time1 <- as.POSIXct("2008-08-03 13:01:59", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 13:01:59", tz = "UTC")
int <- interval(time1, time2)
num <- as.numeric(time2) - as.numeric(time1)
expect_error(x + int)
expect_error(y + int)
expect_error(z + int)
})
test_that("adding vectors works as expected for periods", {
expect_equal(years(1:2) + 1, period(seconds = 1, years = c(1, 2)))
expect_equal(
years(1:2) + as.POSIXct("2008-01-01 00:00:00", tz = "UTC"),
as.POSIXct(c("2009-01-01 00:00:00", "2010-01-01 00:00:00"), tz = "UTC")
)
expect_equal(years(1:2) + as.POSIXlt("2008-01-01 00:00:00",
tz = "UTC"
), as.POSIXlt(c(
"2009-01-01 00:00:00",
"2010-01-01 00:00:00"
), tz = "UTC"))
expect_equal(years(1:2) + minutes(3), period(
minutes = 3, years = c(1, 2)
))
expect_error(years(1:2) + dyears(1))
time1 <- as.POSIXct("2008-01-02 00:00:00", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 00:00:00", tz = "UTC")
int <- interval(time1, time2)
expect_error(years(1:2) + int)
})
test_that("adding vectors works as expected for durations", {
w <- as.POSIXct("2007-01-01 00:00:00", tz = "UTC")
x <- as.POSIXct("2008-01-01 00:00:00", tz = "UTC")
y <- as.POSIXct(c("2008-01-01 00:00:00", "2008-12-31 00:00:00"), tz = "UTC")
dur <- dminutes(1:2) + 1
ddif <- ddays(c(.25, .5))
expect_equal(dur@.Data, c(61, 121))
expect_equal(dyears(1:2) + w - ddif, y)
expect_equal(dyears(1:2) + as.POSIXlt(w) - ddif, as.POSIXlt(y))
expect_error(dyears(1:2) + minutes(3))
expect_equal(dyears(1:2) + dyears(1), dyears(2:3))
time1 <- as.POSIXct("2008-01-02 00:00:00", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 00:00:00", tz = "UTC")
int <- interval(time1, time2)
expect_error(dyears(1:2) + int)
})
test_that("adding vectors works as expected for intervals", {
time1 <- as.POSIXct("2008-08-03 00:00:00", tz = "UTC")
time2 <- as.POSIXct("2009-08-03 00:00:00", tz = "UTC")
time3 <- as.POSIXct("2010-08-03 00:00:00", tz = "UTC")
int <- interval(c(time1, time2), time3)
int2 <- interval(time1, time2)
expect_error(int + time4)
expect_error(int + 1)
expect_error(int + minutes(3))
expect_error(int + dyears(1))
expect_error(int + int2)
})
test_that("%m+% correctly adds months without rollover", {
jan <- ymd_hms("2010-01-31 03:04:05")
ends <- ymd_hms(c("2010-02-28 03:04:05", "2010-03-31 03:04:05", "2010-04-30 03:04:05"))
expect_equal(jan %m+% months(1:3), ends)
})
test_that("%m+% correctly adds years without rollover", {
leap <- ymd("2012-02-29")
next1 <- ymd("2013-02-28")
next2 <- ymd("2013-03-29")
expect_equal(leap %m+% years(1), next1)
expect_equal(leap %m+% period(years = 1, months = 1), next2)
})
test_that("%m+% correctly adds years, months, days and HMS (#286)", {
date <- ymd("2012-02-29")
per_all <- period(years = 1, months = 1, days = 2, hours = 1, minutes = 20, seconds = 30)
per_major <- period(years = 1, months = 1)
per_minor <- period(days = 2, hours = 1, minutes = 20, seconds = 30)
expect_equal(
date %m+% per_all,
date %m+% per_major + per_minor
)
date <- ymd("2012-03-31")
per_all <- period(months = 3, days = 30, hours = 1, minutes = 20, seconds = 30)
per_major <- period(months = 3)
per_minor <- period(days = 30, hours = 1, minutes = 20, seconds = 30)
expect_equal(
date %m+% per_all,
date %m+% per_major + per_minor
)
})
test_that("add_with_rollback doesn't chock on DTS", {
x <- ymd_hms(c("2019-03-29 02:03:00", "2019-03-29 02:11:00"), tz = "Europe/Paris")
y <- ymd_hms(c("2020-03-29 03:00:00", "2020-03-29 03:00:00"), tz = "Europe/Paris")
expect_equal(add_with_rollback(x, years(1)), y)
})
test_that("%m+% correctly adds negative months without rollover", {
may <- ymd_hms("2010-05-31 03:04:05")
ends <- ymd_hms(c("2010-04-30 03:04:05", "2010-03-31 03:04:05", "2010-02-28 03:04:05"))
expect_equal(may %m+% -months(1:3), ends)
})
test_that("%m+% correctly adds negative years without rollover", {
leap <- ymd("2012-02-29")
next1 <- ymd("2011-02-28")
next2 <- ymd("2011-01-29")
next3 <- ymd("2011-03-29")
expect_equal(leap %m+% years(-1), next1)
expect_equal(leap %m+% period(years = -1, months = -1), next2)
expect_equal(leap %m+% period(years = -1, months = 1), next3)
})
test_that("addition with period months and years returns NA when appropriate", {
jan <- ymd("2013-01-31", tz = "America/Chicago")
feb <- ymd("2013-02-28", tz = "America/Chicago")
mar <- ymd("2013-03-28", tz = "America/Chicago")
leap <- ymd("2012-02-29", tz = "America/Chicago")
mos <- ymd(c(
"2013-01-31", NA, "2013-03-31", NA,
"2013-05-31", NA, "2013-07-31",
"2013-08-31", NA, "2013-10-31", NA,
"2013-12-31"
), tz = "America/Chicago")
yrs <- ymd(c("2012-02-29", NA, NA, NA, "2016-02-29"), tz = "America/Chicago")
mos2 <- ymd(c(
"2013-01-31", "2012-12-31", NA,
"2012-10-31", NA, "2012-08-31",
"2012-07-31", NA, "2012-05-31", NA,
"2012-03-31", NA
), tz = "America/Chicago")
yrs2 <- ymd(c("2012-02-29", NA, NA, NA, "2008-02-29"), tz = "America/Chicago")
expect_equal(jan + months(0:11), mos)
expect_equal(feb + months(1), mar)
expect_equal(leap + years(0:4), yrs)
expect_equal(jan - months(0:11), mos2)
expect_equal(mar - months(1), feb)
expect_equal(leap - years(0:4), yrs2)
# Again with Dates (#1069)
jan <- as_date(jan)
feb <- as_date(feb)
mar <- as_date(mar)
leap <- as_date(leap)
mos <- as_date(mos)
yrs <- as_date(yrs)
mos2 <- as_date(mos2)
yrs2 <- as_date(yrs2)
expect_equal(jan + months(0:11), mos)
expect_equal(feb + months(1), mar)
expect_equal(leap + years(0:4), yrs)
expect_equal(jan - months(0:11), mos2)
expect_equal(mar - months(1), feb)
expect_equal(leap - years(0:4), yrs2)
})
test_that("addition with period months recycles correctly", {
x <- as_date(c("2019-01-01", "2019-01-02"))
y <- as_datetime(x, tz = "UTC")
period <- months(1)
x_expect <- as_date(c("2019-02-01", "2019-02-02"))
y_expect <- as_datetime(x_expect, tz = "UTC")
expect_identical(x + period, x_expect)
expect_identical(y + period, y_expect)
period <- months(NA_integer_)
x_expect <- as_date(c(NA, NA))
y_expect <- as_datetime(x_expect, tz = "UTC")
expect_identical(x + period, x_expect)
expect_identical(y + period, y_expect)
period <- months(integer())
expect_error(x + period)
expect_error(y + period)
period <- months(1:3)
expect_error(x + period)
expect_error(y + period)
period <- months(c(1, 2, NA))
expect_error(x + period)
expect_error(y + period)
})
test_that("adding multi unit periods produces NAs on intermediate computation", {
expect_equal(ymd("2021-01-31") + period("1m1d"), NA_Date_)
expect_equal(ymd("2020-02-29") + period("1y1d"), NA_Date_)
expect_equal(ymd("2020-01-29") + period("1y1m1d"), NA_Date_)
expect_equal(ymd("2021-01-31", tz = "UTC") + period("1m1d"), NA_POSIXct_)
expect_equal(ymd("2020-02-29", tz = "UTC") + period("1y1d"), NA_POSIXct_)
expect_equal(ymd("2020-01-29", tz = "UTC") + period("1y1m1d"), NA_POSIXct_)
})
test_that("addition with singleton NAs periods work", {
days1 <- days(NA_real_)
months1 <- months(NA_real_)
years1 <- years(NA_real_)
x <- as.Date("2019-01-01")
y <- as.POSIXct("2019-01-01", "UTC")
expect_equal(x + days1, as.Date(NA))
expect_equal(y + days1, NA_POSIXct_)
expect_equal(x + months1, as.Date(NA))
expect_equal(y + months1, NA_POSIXct_)
expect_equal(x + years1, as.Date(NA))
expect_equal(y + years1, NA_POSIXct_)
})
test_that("addition with durations containing NA", {
dt <- ymd(20161018)
dt_1 <- ymd(20161019)
dd_1na <- ddays(c(1, NA))
dd_na1 <- ddays(c(NA, 1))
dd_nana <- ddays(c(NA, NA))
ans_1na <- add_duration_to_date(dd_1na, dt)
ans_na1 <- add_duration_to_date(dd_na1, dt)
ans_nana <- add_duration_to_date(dd_nana, dt)
expect_s3_class(ans_1na, "Date")
expect_s3_class(ans_na1, "Date")
expect_s3_class(ans_nana, "Date")
expect_equal(ans_1na, c(dt_1, NA))
expect_equal(ans_na1, rev(c(dt_1, NA)))
expect_equal(ans_nana, as.Date(c(NA, NA)))
})
test_that("addition works correctly for DST transitions", {
ref <- ymd("2017-10-01", tz = "Australia/Melbourne")
expect_equal(ref + hours(1:3), ref + dhours(c(1, NA, 2)))
ref <- ymd_hms("2022-10-30 00:00:00", tz = "Europe/Amsterdam")
expect_equal(ref + hours(1:3), ref + dhours(c(1, 2, 4)))
ref <- ymd_hms("2022-03-27 00:00:00", tz = "Europe/Amsterdam")
expect_equal(ref + hours(1:3), ref + dhours(c(1, NA, 2)))
})
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.