Running ‘testthat.R’ [19s/19s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > if (packageVersion("testthat") >= "0.7.1.99") {
  +   library(testthat)  
  +   test_check("lubridate")
  + }
  Loading required package: lubridate
  
  Attaching package: 'lubridate'
  
  The following object is masked from 'package:base':
  
      date
  
  1. Error: converts character (@test-POSIXt.R#45) -------------------------------
  CCTZ: Unrecognized output timezone: "Europe/Amsterdam"
  1: expect_equal(as_datetime(chars, tz = "Europe/Amsterdam"), ymd_hms(chars, tz = "Europe/Amsterdam", 
         quiet = TRUE)) at testthat/test-POSIXt.R:45
  2: compare(object, expected, ...)
  3: as_datetime(chars, tz = "Europe/Amsterdam")
  4: as_datetime(chars, tz = "Europe/Amsterdam")
  5: .local(x, ...)
  6: parse_date_time(x, orders = c("ymdTz", "ymdT"), tz = tz)
  7: .local_parse(x[to_parse], TRUE)
  8: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  9: .parse_date_time(newx, formats[-1], tz = tz, quiet = quiet, locale = locale)
  10: .parse_date_time(newx, formats[-1], tz = tz, quiet = quiet, locale = locale)
  11: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  12: force_tz(out, tzone = tz)
  13: C_force_tz(time, tz = tzone, roll)
  
  2. Error: changes timezone of POSIXct (@test-POSIXt.R#49) ----------------------
  CCTZ: Unrecognized tzone: "America/Chicago"
  1: as_datetime(make_datetime(tz = "America/Chicago")) at testthat/test-POSIXt.R:49
  2: make_datetime(tz = "America/Chicago")
  3: C_update_dt(.rep_maybe(origin, N), year = .rep_maybe(year, N), month = .rep_maybe(month, 
         N), yday = integer(), mday = .rep_maybe(day, N), wday = integer(), hour = .rep_maybe(hour, 
         N), minute = .rep_maybe(min, N), second = .rep_maybe(sec, N), tz = tz)
  
  3. Error: isoweek returns correct value for non-UTC time zone (#311) (@test-accessors.R#195) 
  CCTZ: Unrecognized output timezone: "Europe/Copenhagen"
  1: ymd_hms("2015-04-14 16:45:00", tz = "Europe/Copenhagen") at testthat/test-accessors.R:195
  2: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  3: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  4. Error: force_tz returns NA for a time that falls in the spring gap (@test-daylight-savings.R#7) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: expect_true(is.na(force_tz(x, "America/New_York"))) at testthat/test-daylight-savings.R:7
  2: expect(identical(as.vector(object), TRUE), sprintf("%s isn't true.", lab), info = info)
  3: as.expectation(exp, ..., srcref = srcref)
  4: identical(as.vector(object), TRUE)
  5: as.vector(object)
  6: force_tz(x, "America/New_York")
  7: C_force_tz(time, tz = tzone, roll)
  
  5. Error: force_tz behaves consistently for the fall overlap (@test-daylight-savings.R#24) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(y + hours(1), y2) at testthat/test-daylight-savings.R:24
  2: compare(object, expected, ...)
  3: y + hours(1)
  4: y + hours(1)
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 5, min = 30L, hour = 1L, mday = 7L, mon = 10, year = 110L, 
         wday = 0L, yday = 310L, isdst = 0L, zone = "EST", gmtoff = -18000L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 7, hours = 2, minutes = 30, seconds = 5)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 7, wday = integer(0), 
         hour = 2, minute = 30, second = 5, dt = structure(1289111405, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  6. Error: addition handles daylight savings time for spring gap (@test-daylight-savings.R#39) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(x + days(1), px) at testthat/test-daylight-savings.R:39
  2: compare(object, expected, ...)
  3: x + days(1)
  4: x + days(1)
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 14L, mon = 2, year = 110L, 
         wday = 0L, yday = 72L, isdst = 0L, zone = "EST", gmtoff = -18000L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 15, hours = 0, minutes = 0, seconds = 0)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 15, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1268542800, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  7. Error: subtraction handles daylight savings time for spring gap (@test-daylight-savings.R#54) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(x - days(1), px) at testthat/test-daylight-savings.R:54
  2: compare(object, expected, ...)
  3: x - days(1)
  4: x - days(1)
  5: e1 + (-e2)
  6: e1 + (-e2)
  7: add_period_to_date(e2, e1)
  8: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  10: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  11: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 15L, mon = 2, year = 110L, 
         wday = 1L, yday = 73L, isdst = 1L, zone = "EDT", gmtoff = -14400L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 14, hours = 0, minutes = 0, seconds = 0)
  12: reclass_date(do.call(C_update_dt, updates), object)
  13: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  14: as.POSIXlt(new)
  15: do.call(C_update_dt, updates)
  16: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1268625600, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  8. Error: addition handles daylight savings time for fall overlap (@test-daylight-savings.R#68) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(x + days(1), px) at testthat/test-daylight-savings.R:68
  2: compare(object, expected, ...)
  3: x + days(1)
  4: x + days(1)
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 7L, mon = 10, year = 110L, 
         wday = 0L, yday = 310L, isdst = 1L, zone = "EDT", gmtoff = -14400L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 8, hours = 0, minutes = 0, seconds = 0)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 8, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1289102400, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  9. Error: subtraction handles daylight savings time for fall overlap (@test-daylight-savings.R#82) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(x - days(1), px) at testthat/test-daylight-savings.R:82
  2: compare(object, expected, ...)
  3: x - days(1)
  4: x - days(1)
  5: e1 + (-e2)
  6: e1 + (-e2)
  7: add_period_to_date(e2, e1)
  8: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  10: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  11: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 8L, mon = 10, year = 110L, 
         wday = 1L, yday = 311L, isdst = 0L, zone = "EST", gmtoff = -18000L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 7, hours = 0, minutes = 0, seconds = 0)
  12: reclass_date(do.call(C_update_dt, updates), object)
  13: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  14: as.POSIXlt(new)
  15: do.call(C_update_dt, updates)
  16: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 7, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1289192400, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  10. Error: update returns NA for date-times in the spring dst gap (@test-daylight-savings.R#108) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_true(is.na(update(poslt, seconds = 61))) at testthat/test-daylight-savings.R:108
  2: expect(identical(as.vector(object), TRUE), sprintf("%s isn't true.", lab), info = info)
  3: as.expectation(exp, ..., srcref = srcref)
  4: identical(as.vector(object), TRUE)
  5: as.vector(object)
  6: update(poslt, seconds = 61)
  7: update.POSIXt(poslt, seconds = 61)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 2L, year = 110L, 
         wday = 0L, yday = 72L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = c("America/New_York", 
     "EST", "EDT")), roll = FALSE, week_start = 7, seconds = 61)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 61, dt = structure(1268549999, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  11. Error: update rollovers perform correctly across the fall overlap (@test-daylight-savings.R#148) 
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(update(timest, minutes = 121), timest2) at testthat/test-daylight-savings.R:148
  2: compare(object, expected, ...)
  3: update(timest, minutes = 121)
  4: update.POSIXt(timest, minutes = 121)
  5: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  6: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1289113199, tzone = "America/New_York", class = c("POSIXct", "POSIXt"
     )), roll = FALSE, week_start = 7, minutes = 121)
  7: reclass_date(do.call(C_update_dt, updates), object)
  8: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  9: as.POSIXct(new)
  10: do.call(C_update_dt, updates)
  11: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = 121, second = numeric(0), dt = structure(1289113199, tzone = "America/New_York", class = c("POSIXct", 
         "POSIXt")), roll = FALSE, tz = "America/New_York", week_start = 7)
  
  12. Error: arithmetic handles fall gap in timespan appropriate way (@test-daylight-savings.R#157) 
  Invalid timezone of input vector: "America/Chicago"
  1: expect_equal(cdst - seconds(1), cdst - 3601) at testthat/test-daylight-savings.R:157
  2: compare(object, expected, ...)
  3: cdst - seconds(1)
  4: cdst - seconds(1)
  5: e1 + (-e2)
  6: e1 + (-e2)
  7: add_period_to_date(e2, e1)
  8: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  10: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  11: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 1L, mday = 4L, mon = 10, year = 112L, 
         wday = 0L, yday = 308L, isdst = 0L, zone = "CST", gmtoff = -21600L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/Chicago", "CST", "CDT")), roll = FALSE, week_start = 7, 
         days = 4, hours = 1, minutes = 0, seconds = -1)
  12: reclass_date(do.call(C_update_dt, updates), object)
  13: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  14: as.POSIXlt(new)
  15: do.call(C_update_dt, updates)
  16: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 4, wday = integer(0), 
         hour = 1, minute = 0, second = -1, dt = structure(1352012400, class = c("POSIXct", 
         "POSIXt"), tzone = "America/Chicago"), roll = FALSE, tz = "America/Chicago", 
         week_start = 7)
  
  13. Error: date_decimal reverses decimal_date (@test-decimal-date.R#37) --------
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: ymd_hms("2008-02-03 10:01:59", tz = "America/New_York") at testthat/test-decimal-date.R:37
  2: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  3: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  14. Error: decimal_date correctly handles daylight savings time (@test-decimal-date.R#54) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: ymd_hms("2016-03-13 01:00:00", tz = "America/New_York") at testthat/test-decimal-date.R:54
  2: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  3: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  15. Error: make_datetime replicates as expected (@test-instants.R#58) ----------
  CCTZ: Unrecognized tzone: "America/New_York"
  1: expect_equal(make_datetime(year = c(1999, 2000, 3000), month = c(11, 12), day = 22, 
         sec = c(10, 11, 13, 13), tz = "America/New_York"), ymd_hms(c("1999-11-22 00:00:10", 
         "2000-12-22 00:00:11", "3000-11-22 00:00:13", "1999-12-22 00:00:13"), tz = "America/New_York")) at testthat/test-instants.R:58
  2: compare(object, expected, ...)
  3: make_datetime(year = c(1999, 2000, 3000), month = c(11, 12), day = 22, sec = c(10, 
         11, 13, 13), tz = "America/New_York")
  4: C_update_dt(.rep_maybe(origin, N), year = .rep_maybe(year, N), month = .rep_maybe(month, 
         N), yday = integer(), mday = .rep_maybe(day, N), wday = integer(), hour = .rep_maybe(hour, 
         N), minute = .rep_maybe(min, N), second = .rep_maybe(sec, N), tz = tz)
  
  16. Error: setdiff.Interval works as expected (@test-intervals.R#488) ----------
  CCTZ: Unrecognized output timezone: "Pacific/Auckland"
  1: ymd_hms("2011-06-04 12:00:00", tz = "Pacific/Auckland") at testthat/test-intervals.R:488
  2: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  3: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  17. Error: addition handles daylight savings time (@test-ops-addition.R#7) -----
  Invalid timezone of input vector: "America/New_York"
  1: expect_that(x + days(1), equals(as.POSIXct("2010-03-15 00:00:00", tz = "America/New_York"))) at testthat/test-ops-addition.R:7
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: x + days(1)
  6: x + days(1)
  7: add_period_to_date(e2, e1)
  8: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  10: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  11: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 14L, mon = 2, year = 110L, 
         wday = 0L, yday = 72L, isdst = 0L, zone = "EST", gmtoff = -18000L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 15, hours = 0, minutes = 0, seconds = 0)
  12: reclass_date(do.call(C_update_dt, updates), object)
  13: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  14: as.POSIXlt(new)
  15: do.call(C_update_dt, updates)
  16: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 15, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1268542800, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  18. Error: subtraction handles daylight savings time (@test-ops-addition.R#16) -
  Invalid timezone of input vector: "America/New_York"
  1: expect_that(x - days(1), equals(as.POSIXct("2010-03-14 00:00:00", tz = "America/New_York"))) at testthat/test-ops-addition.R:16
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: x - days(1)
  6: x - days(1)
  7: e1 + (-e2)
  8: e1 + (-e2)
  9: add_period_to_date(e2, e1)
  10: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  11: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  12: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  13: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 15L, mon = 2, year = 110L, 
         wday = 1L, yday = 73L, isdst = 1L, zone = "EDT", gmtoff = -14400L), .Names = c("sec", 
     "min", "hour", "mday", "mon", "year", "wday", "yday", "isdst", "zone", "gmtoff"), class = c("POSIXlt", 
     "POSIXt"), tzone = c("America/New_York", "EST", "EDT")), roll = FALSE, week_start = 7, 
         days = 14, hours = 0, minutes = 0, seconds = 0)
  14: reclass_date(do.call(C_update_dt, updates), object)
  15: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  16: as.POSIXlt(new)
  17: do.call(C_update_dt, updates)
  18: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 0, minute = 0, second = 0, dt = structure(1268625600, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  19. Error: addition with period months and years returns NA when appropriate (@test-ops-addition.R#290) 
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: ymd("2013-01-31", tz = "America/Chicago") at testthat/test-ops-addition.R:290
  2: .parse_xxx(..., orders = "ymd", quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  3: parse_date_time(dates, orders, quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  20. Error: Comparison operators work with POSIX and Date objects (@test-ops-compare.R#14) 
  CCTZ: Unrecognized output timezone: "Europe/Paris"
  1: expect_true(ymd("2016-01-03") > ymd_hms("2016-01-02 23:59:59", tz = "Europe/Paris")) at testthat/test-ops-compare.R:14
  2: expect(identical(as.vector(object), TRUE), sprintf("%s isn't true.", lab), info = info)
  3: as.expectation(exp, ..., srcref = srcref)
  4: identical(as.vector(object), TRUE)
  5: as.vector(object)
  6: ymd_hms("2016-01-02 23:59:59", tz = "Europe/Paris")
  7: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  8: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  9: .local_parse(x[to_parse], TRUE)
  10: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  11: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  12: force_tz(out, tzone = tz)
  13: C_force_tz(time, tz = tzone, roll)
  
  21. Error: ymd_hms treats time zones correctly (@test-parsers.R#825) -----------
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: expect_that(ymd_hms("2012-03-03 23:06:07", tz = "America/Chicago"), equals(as.POSIXct("2012-03-03 23:06:07", 
         tz = "America/Chicago"))) at testthat/test-parsers.R:825
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: ymd_hms("2012-03-03 23:06:07", tz = "America/Chicago")
  6: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  7: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  8: .local_parse(x[to_parse], TRUE)
  9: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  10: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  11: force_tz(out, tzone = tz)
  12: C_force_tz(time, tz = tzone, roll)
  
  22. Error: ymd_hms parses Ou format correctly  (@test-parsers.R#833) -----------
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: expect_that(ymd_hms("2012-03-04T05:06:07Z", tz = "America/Chicago"), equals(ymd_hms("2012-03-03 23:06:07", 
         tz = "America/Chicago"))) at testthat/test-parsers.R:833
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: compare.POSIXt(object, expected, ...)
  6: inherits(y, "POSIXt")
  7: ymd_hms("2012-03-03 23:06:07", tz = "America/Chicago")
  8: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  9: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  10: .local_parse(x[to_parse], TRUE)
  11: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  12: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  13: force_tz(out, tzone = tz)
  14: C_force_tz(time, tz = tzone, roll)
  
  23. Error: ymd_hms parses OO and Oo formats correctly (@test-parsers.R#866) ----
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: expect_that(ymd_hms("2012-03-04T05:06:07-01:30", tz = "America/Chicago", quiet = T), 
         equals(ymd_hms("2012-03-04 00:36:07", tz = "America/Chicago"))) at testthat/test-parsers.R:866
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: compare.POSIXt(object, expected, ...)
  6: inherits(y, "POSIXt")
  7: ymd_hms("2012-03-04 00:36:07", tz = "America/Chicago")
  8: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  9: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  10: .local_parse(x[to_parse], TRUE)
  11: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  12: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  13: force_tz(out, tzone = tz)
  14: C_force_tz(time, tz = tzone, roll)
  
  24. Error: ymd_hms parses mixed ISO-8601/non-ISO-8601 formats (@test-parsers.R#883) 
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: expect_that(ymd_hms(c("2012-03-04T05:06:07Z", "2001-02-03 04:05:06"), tz = "America/Chicago"), 
         equals(ymd_hms(c("2012-03-03 23:06:07", "2001-02-03 04:05:06"), tz = "America/Chicago"))) at testthat/test-parsers.R:883
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: ymd_hms(c("2012-03-04T05:06:07Z", "2001-02-03 04:05:06"), tz = "America/Chicago")
  6: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  7: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  8: .local_parse(x[to_parse], TRUE)
  9: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  10: .parse_date_time(newx, formats[-1], tz = tz, quiet = quiet, locale = locale)
  11: .parse_date_time(newx, formats[-1], tz = tz, quiet = quiet, locale = locale)
  12: .parse_date_time(newx, formats[-1], tz = tz, quiet = quiet, locale = locale)
  13: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  14: force_tz(out, tzone = tz)
  15: C_force_tz(time, tz = tzone, roll)
  
  25. Error: parse_date_time2 and fast_strptime correctly work with timezones (@test-parsers.R#909) 
  CCTZ: Unrecognized output timezone: "Europe/Zurich"
  1: 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")) at testthat/test-parsers.R:909
  2: compare(object, expected, ...)
  3: parse_date_time("12/03/16 12:00", "dmy HM", tz = "Europe/Zurich")
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  26. Error: floor_date and ceiling_date work with leap years (@test-round.R#126) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: 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")) at testthat/test-round.R:126
  2: compare(object, expected, ...)
  3: floor_date(ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30"), tz = "America/New_York"), 
         "year")
  4: ymd_hms(c("2016-02-29 1:2:3", "2016-03-01 10:20:30"), tz = "America/New_York")
  5: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  6: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  7: .local_parse(x[to_parse], TRUE)
  8: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  9: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  10: force_tz(out, tzone = tz)
  11: C_force_tz(time, tz = tzone, roll)
  
  27. Error: rounding works across DST (@test-round.R#268) -----------------------
  CCTZ: Unrecognized output timezone: "Europe/Helsinki"
  1: ymd("2016-03-27", tz = "Europe/Helsinki") at testthat/test-round.R:268
  2: .parse_xxx(..., orders = "ymd", quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  3: parse_date_time(dates, orders, quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  28. Error: round_date and ceiling_date skip day time gap (@test-round.R#369) ---
  CCTZ: Unrecognized output timezone: "Europe/Amsterdam"
  1: 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) at testthat/test-round.R:369
  2: .parse_xxx_hms(..., orders = c("ymdTz", "ymdT"), quiet = quiet, tz = tz, locale = locale, 
         truncated = truncated)
  3: parse_date_time(dates, orders, tz = tz, quiet = quiet, locale = locale)
  4: .local_parse(x[to_parse], TRUE)
  5: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  6: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  7: force_tz(out, tzone = tz)
  8: C_force_tz(time, tz = tzone, roll)
  
  29. Error: floor_date works for seasons (@test-round.R#422) --------------------
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(dts, "America/New_York") at testthat/test-round.R:422
  2: C_force_tz(time, tz = tzone, roll)
  
  30. Error: ceiling_date works for seasons (@test-round.R#429) ------------------
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(dts, "America/New_York") at testthat/test-round.R:429
  2: C_force_tz(time, tz = tzone, roll)
  
  31. Error: round on week respects week_start (@test-round.R#438) ---------------
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(wday(floor_date(ct, "week", week_start = 1)), 2) at testthat/test-round.R:438
  2: compare(object, expected, ...)
  3: wday(floor_date(ct, "week", week_start = 1))
  4: floor_date(ct, "week", week_start = 1)
  5: update(x, wdays = 1, hours = 0, minutes = 0, seconds = 0, week_start = week_start)
  6: update.POSIXt(x, wdays = 1, hours = 0, minutes = 0, seconds = 0, week_start = week_start)
  7: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  8: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1265222759, class = c("POSIXct", "POSIXt"), tzone = "America/New_York"), 
         roll = FALSE, week_start = 1, wdays = 1, hours = 0, minutes = 0, seconds = 0)
  9: reclass_date(do.call(C_update_dt, updates), object)
  10: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  11: as.POSIXct(new)
  12: do.call(C_update_dt, updates)
  13: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = 1, 
         hour = 0, minute = 0, second = 0, dt = structure(1265222759, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 1)
  
  32. Error: seconds settor does not change time zone (@test-settors.R#67) -------
  Invalid timezone of input vector: "GMT"
  1: `second<-`(`*tmp*`, value = 1) at testthat/test-settors.R:67
  2: `second<-`(`*tmp*`, value = 1)
  3: x + seconds(value - second(x))
  4: x + seconds(value - second(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 1)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 1, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  33. Error: seconds settor returns NA for spring dst gap (@test-settors.R#87) ---
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:87
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  34. Error: seconds settor retains object class (@test-settors.R#104) -----------
  Invalid timezone of input vector: "GMT"
  1: `second<-`(`*tmp*`, value = 10) at testthat/test-settors.R:104
  2: `second<-`(`*tmp*`, value = 10)
  3: x + seconds(value - second(x))
  4: x + seconds(value - second(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 10)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 10, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  35. Error: minutes settor does not change time zone (@test-settors.R#188) ------
  Invalid timezone of input vector: "GMT"
  1: `minute<-`(`*tmp*`, value = 1) at testthat/test-settors.R:188
  2: `minute<-`(`*tmp*`, value = 1)
  3: x + minutes(value - minute(x))
  4: x + minutes(value - minute(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 1, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 1, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  36. Error: minutes settor returns NA for spring dst gap (@test-settors.R#209) --
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:209
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  37. Error: minutes settor retains object class (@test-settors.R#226) -----------
  Invalid timezone of input vector: "GMT"
  1: `minute<-`(`*tmp*`, value = 1) at testthat/test-settors.R:226
  2: `minute<-`(`*tmp*`, value = 1)
  3: x + minutes(value - minute(x))
  4: x + minutes(value - minute(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 1, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 1, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  38. Error: hours settor does not change time zone (@test-settors.R#308) --------
  Invalid timezone of input vector: "GMT"
  1: `hour<-`(`*tmp*`, value = 1) at testthat/test-settors.R:308
  2: `hour<-`(`*tmp*`, value = 1)
  3: x + hours(value - hour(x))
  4: x + hours(value - hour(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  39. Error: hours settor returns NA for spring dst gap (@test-settors.R#329) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:329
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  40. Error: hours settor retains object class (@test-settors.R#346) -------------
  Invalid timezone of input vector: "GMT"
  1: `hour<-`(`*tmp*`, value = 2) at testthat/test-settors.R:346
  2: `hour<-`(`*tmp*`, value = 2)
  3: x + hours(value - hour(x))
  4: x + hours(value - hour(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 2, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 2, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  41. Error: mdays settor does not change time zone (@test-settors.R#438) --------
  Invalid timezone of input vector: "GMT"
  1: `mday<-`(`*tmp*`, value = 1) at testthat/test-settors.R:438
  2: `day<-`(`*tmp*`, value = 1)
  3: `day<-`(`*tmp*`, value = 1)
  4: x + days(value - mday(x))
  5: x + days(value - mday(x))
  6: add_period_to_date(e2, e1)
  7: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  10: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 1, hours = 1, minutes = 59, seconds = 59)
  11: reclass_date(do.call(C_update_dt, updates), object)
  12: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  13: as.POSIXlt(new)
  14: do.call(C_update_dt, updates)
  15: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 1, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  42. Error: mdays settor returns NA for spring dst gap (@test-settors.R#459) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:459
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  43. Error: mdays settor retains object class (@test-settors.R#476) -------------
  Invalid timezone of input vector: "GMT"
  1: `mday<-`(`*tmp*`, value = 3) at testthat/test-settors.R:476
  2: `day<-`(`*tmp*`, value = 3)
  3: `day<-`(`*tmp*`, value = 3)
  4: x + days(value - mday(x))
  5: x + days(value - mday(x))
  6: add_period_to_date(e2, e1)
  7: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  9: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  10: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 3, hours = 1, minutes = 59, seconds = 59)
  11: reclass_date(do.call(C_update_dt, updates), object)
  12: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  13: as.POSIXlt(new)
  14: do.call(C_update_dt, updates)
  15: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 3, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  44. Error: ydays settor does not change time zone (@test-settors.R#567) --------
  Invalid timezone of input vector: "GMT"
  1: `yday<-`(`*tmp*`, value = 1) at testthat/test-settors.R:567
  2: x + days(value - yday(x))
  3: x + days(value - yday(x))
  4: add_period_to_date(e2, e1)
  5: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  6: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  8: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = -30, hours = 1, minutes = 59, seconds = 59)
  9: reclass_date(do.call(C_update_dt, updates), object)
  10: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  11: as.POSIXlt(new)
  12: do.call(C_update_dt, updates)
  13: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = -30, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  45. Error: ydays settor returns NA for spring dst gap (@test-settors.R#588) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:588
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  46. Error: ydays settor retains object class (@test-settors.R#605) -------------
  Invalid timezone of input vector: "GMT"
  1: `yday<-`(`*tmp*`, value = 3) at testthat/test-settors.R:605
  2: x + days(value - yday(x))
  3: x + days(value - yday(x))
  4: add_period_to_date(e2, e1)
  5: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  6: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  8: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = -28, hours = 1, minutes = 59, seconds = 59)
  9: reclass_date(do.call(C_update_dt, updates), object)
  10: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  11: as.POSIXlt(new)
  12: do.call(C_update_dt, updates)
  13: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = -28, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  47. Error: wdays settor does not change time zone (@test-settors.R#697) --------
  Invalid timezone of input vector: "GMT"
  1: `wday<-`(`*tmp*`, value = 2) at testthat/test-settors.R:697
  2: x + days(value - wday(x, week_start = week_start))
  3: x + days(value - wday(x, week_start = week_start))
  4: add_period_to_date(e2, e1)
  5: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  6: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  8: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 15, hours = 1, minutes = 59, seconds = 59)
  9: reclass_date(do.call(C_update_dt, updates), object)
  10: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  11: as.POSIXlt(new)
  12: do.call(C_update_dt, updates)
  13: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 15, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  48. Error: wdays settor returns NA for spring dst gap (@test-settors.R#718) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:718
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  49. Error: wdays settor retains object class (@test-settors.R#735) -------------
  Invalid timezone of input vector: "GMT"
  1: `wday<-`(`*tmp*`, value = 3) at testthat/test-settors.R:735
  2: x + days(value - wday(x, week_start = week_start))
  3: x + days(value - wday(x, week_start = week_start))
  4: add_period_to_date(e2, e1)
  5: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  6: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  8: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 16, hours = 1, minutes = 59, seconds = 59)
  9: reclass_date(do.call(C_update_dt, updates), object)
  10: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  11: as.POSIXlt(new)
  12: do.call(C_update_dt, updates)
  13: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 16, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  50. Error: months settor does not change time zone (@test-settors.R#817) -------
  Invalid timezone of input vector: "GMT"
  1: `month<-`(`*tmp*`, value = 1) at testthat/test-settors.R:817
  2: `month<-`(`*tmp*`, value = 1)
  3: x + months(value - month(x))
  4: x + months(value - month(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 0, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1263434399, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  51. Error: months settor returns NA for spring dst gap (@test-settors.R#838) ---
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:838
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  52. Error: months settor retains object class (@test-settors.R#854) ------------
  Invalid timezone of input vector: "GMT"
  1: `month<-`(`*tmp*`, value = 1) at testthat/test-settors.R:854
  2: `month<-`(`*tmp*`, value = 1)
  3: x + months(value - month(x))
  4: x + months(value - month(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 0, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1263434399, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  53. Error: years settor does not change time zone (@test-settors.R#895) --------
  Invalid timezone of input vector: "GMT"
  1: `year<-`(`*tmp*`, value = 2000) at testthat/test-settors.R:895
  2: `year<-`(`*tmp*`, value = 2000)
  3: x + years(value - year(x))
  4: x + years(value - year(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = -119, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(950493599, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  54. Error: years settor returns NA for spring dst gap (@test-settors.R#908) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:908
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  55. Error: years settor retains object class (@test-settors.R#925) -------------
  Invalid timezone of input vector: "GMT"
  1: `year<-`(`*tmp*`, value = 2000) at testthat/test-settors.R:925
  2: `year<-`(`*tmp*`, value = 2000)
  3: x + years(value - year(x))
  4: x + years(value - year(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = -119, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = 14, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = 14, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(950493599, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  56. Error: dates settor does not change time zone (@test-settors.R#956) --------
  Invalid timezone of input vector: "GMT"
  1: `date<-`(`*tmp*`, value = structure(10957, class = "Date")) at testthat/test-settors.R:956
  2: `date<-`(`*tmp*`, value = structure(10957, class = "Date"))
  3: x + days(date(value) - date(x))
  4: x + days(date(value) - date(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = -3683, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = -3683, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  57. Error: dates settor returns NA for spring dst gap (@test-settors.R#968) ----
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-settors.R:968
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  58. Error: dates settor retains object class (@test-settors.R#984) -------------
  Invalid timezone of input vector: "GMT"
  1: `date<-`(`*tmp*`, value = structure(10957, class = "Date")) at testthat/test-settors.R:984
  2: `date<-`(`*tmp*`, value = structure(10957, class = "Date"))
  3: x + days(date(value) - date(x))
  4: x + days(date(value) - date(x))
  5: add_period_to_date(e2, e1)
  6: update(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  7: update.POSIXt(lt, days = mday(lt) + per@day, hours = hour(lt) + per@hour, minutes = minute(lt) + 
         per@minute, seconds = second(lt) + per@.Data)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 59L, hour = 1L, mday = 14L, mon = 1, year = 110L, 
         wday = 0L, yday = 44L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, days = -3683, hours = 1, minutes = 59, seconds = 59)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = -3683, wday = integer(0), 
         hour = 1, minute = 59, second = 59, dt = structure(1266112799, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  59. Error: time zone settor correctly performs simple updates (@test-settors.R#1000) 
  CCTZ: Unrecognized output timezone: "GMT"
  1: `tz<-`(`*tmp*`, value = "GMT") at testthat/test-settors.R:1000
  2: force_tz(x, value)
  3: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  60. Error: time zone settor returns NA for spring dst gap (@test-settors.R#1015) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: `tz<-`(`*tmp*`, value = "America/New_York") at testthat/test-settors.R:1015
  2: force_tz(x, value)
  3: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  61. Error: time zone settor retains object class (@test-settors.R#1029) --------
  CCTZ: Unrecognized output timezone: "GMT"
  1: `tz<-`(`*tmp*`, value = "GMT") at testthat/test-settors.R:1029
  2: force_tz(x, value)
  3: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  62. Error: settors handle vectors (@test-settors.R#1125) -----------------------
  CCTZ: Unrecognized output timezone: "GMT"
  1: `tz<-`(`*tmp*`, value = "GMT") at testthat/test-settors.R:1125
  2: force_tz(x, value)
  3: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  63. Error: .format_offset works as expected (@test-stamp.R#56) -----------------
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: with(df_winter, for (i in 1:nrow(df_winter)) {
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%Oo"), Oo[i])
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%Oz"), Oz[i])
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%OO"), OO[i])
     }) at testthat/test-stamp.R:56
  2: with.default(df_winter, for (i in 1:nrow(df_winter)) {
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%Oo"), Oo[i])
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%Oz"), Oz[i])
         expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%OO"), OO[i])
     })
  3: eval(substitute(expr), data, enclos = parent.frame())
  4: eval(substitute(expr), data, enclos = parent.frame())
  5: expect_equal(.format_offset(ymd("2013-01-01", tz = tz[i]), "%Oo"), Oo[i]) at testthat/test-stamp.R:58
  6: compare(object, expected, ...)
  7: .format_offset(ymd("2013-01-01", tz = tz[i]), "%Oo")
  8: force_tz(x, tzone = "UTC")
  9: is.data.frame(time)
  10: ymd("2013-01-01", tz = tz[i])
  11: .parse_xxx(..., orders = "ymd", quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  12: parse_date_time(dates, orders, quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  13: .local_parse(x[to_parse], TRUE)
  14: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  15: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  16: force_tz(out, tzone = tz)
  17: C_force_tz(time, tz = tzone, roll)
  
  64. Error: stamp works with ISO-8601 formats (@test-stamp.R#102) ---------------
  CCTZ: Unrecognized output timezone: "America/Chicago"
  1: expect_equal(stamp_Ou(ymd("2013-01-01", tz = tz[i])), Ou[i]) at testthat/test-stamp.R:102
  2: compare(object, expected, ...)
  3: stamp_Ou(ymd("2013-01-01", tz = tz[i]))
  4: tz(x[[1]])
  5: ymd("2013-01-01", tz = tz[i])
  6: .parse_xxx(..., orders = "ymd", quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  7: parse_date_time(dates, orders, quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  8: .local_parse(x[to_parse], TRUE)
  9: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  10: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  11: force_tz(out, tzone = tz)
  12: C_force_tz(time, tz = tzone, roll)
  
  65. Error: force_tzs works as expected (@test-timezones.R#41) ------------------
  CCTZ: Unrecognized timezone: "America/New_York"
  1: expect_equal(force_tzs(x, tzones = c("America/New_York", "Europe/Amsterdam")), ymd_hms("2009-08-07 04:00:01 UTC", 
         "2009-08-06 22:00:01 UTC")) at testthat/test-timezones.R:41
  2: compare(object, expected, ...)
  3: force_tzs(x, tzones = c("America/New_York", "Europe/Amsterdam"))
  4: C_force_tzs(as.POSIXct(time), tzones, tzone_out, roll)
  
  66. Error: force_tzs is robusts against overflow (@test-timezones.R#58) --------
  CCTZ: Unrecognized timezone: "America/New_York"
  1: expect_equal(force_tzs(x, tzones = "America/New_York"), with_tz(ymd_hms(c("2038-01-19 03:14:06", 
         "2038-01-19 03:14:07", "2038-01-19 03:14:08", "2038-01-19 03:14:09", "2038-01-19 03:14:10"), 
         tz = "America/New_York"), "UTC")) at testthat/test-timezones.R:58
  2: compare(object, expected, ...)
  3: force_tzs(x, tzones = "America/New_York")
  4: C_force_tzs(as.POSIXct(time), tzones, tzone_out, roll)
  
  67. Error: local_time works as expected (@test-timezones.R#71) -----------------
  CCTZ: Unrecognized timezone: "Europe/Amsterdam"
  1: expect_equal(local_time(x, "Europe/Amsterdam"), local_time(with_tz(x, "Europe/Amsterdam"))) at testthat/test-timezones.R:71
  2: compare(object, expected, ...)
  3: local_time(x, "Europe/Amsterdam")
  4: C_local_time(as.POSIXct(dt), tz)
  
  68. Failure: with_tz throws warning on unrecognized time zones (@test-timezones.R#85) 
  with_tz(now(), "America/New_York") produced warnings.
  
  
  69. Error: force_tz works as expected (@test-timezones.R#90) -------------------
  CCTZ: Unrecognized timezone of the input vector: "America/New_York"
  1: expect_that(force_tz(x, "UTC"), equals(as.POSIXct(format(as.POSIXct(x)), tz = "UTC"))) at testthat/test-timezones.R:90
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: force_tz(x, "UTC")
  6: C_force_tz(time, tz = tzone, roll)
  
  70. Error: force_tz handles vectors (@test-timezones.R#96) ---------------------
  CCTZ: Unrecognized timezone of the input vector: "America/New_York"
  1: expect_that(force_tz(x, "UTC"), equals(as.POSIXct(format(as.POSIXct(x)), tz = "UTC"))) at testthat/test-timezones.R:96
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: force_tz(x, "UTC")
  6: C_force_tz(time, tz = tzone, roll)
  
  71. Error: force_tz handles various date-time classes (@test-timezones.R#102) --
  CCTZ: Unrecognized timezone of the input vector: "America/New_York"
  1: expect_equal(force_tz(as.POSIXlt(x), "UTC"), as.POSIXlt(format(x), tz = "UTC")) at testthat/test-timezones.R:102
  2: compare(object, expected, ...)
  3: force_tz(as.POSIXlt(x), "UTC")
  4: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  72. Error: force_tz handles data.frames (@test-timezones.R#110) ----------------
  CCTZ: Unrecognized timezone of the input vector: "America/New_York"
  1: force_tz(df, "UTC") at testthat/test-timezones.R:110
  2: force_tz(time[[nm]], tzone = tzone)
  3: C_force_tz(time, tz = tzone, roll)
  
  73. Error: force_tz doesn't return NA just because new time zone uses DST (@test-timezones.R#118) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-timezones.R:118
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  74. Error: update.POSIXlt returns a POSIXlt object (@test-update.R#24) ---------
  Invalid timezone of input vector: "GMT"
  1: expect_that(update(poslt, seconds = 1), is_a("POSIXlt")) at testthat/test-update.R:24
  2: condition(object)
  3: expect_is(x, class)
  4: klass(object)
  5: paste(class(x), collapse = "/")
  6: update(poslt, seconds = 1)
  7: update.POSIXt(poslt, seconds = 1)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 45L, hour = 13L, mday = 3L, mon = 1L, year = 110L, 
         wday = 3L, yday = 33L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, seconds = 1)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 1, dt = structure(1265204759, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  75. Error: update.POSIXct returns a POSIXct object (@test-update.R#39) ---------
  Invalid timezone of input vector: "GMT"
  1: expect_that(update(posct, seconds = 1), is_a("POSIXct")) at testthat/test-update.R:39
  2: condition(object)
  3: expect_is(x, class)
  4: klass(object)
  5: paste(class(x), collapse = "/")
  6: update(posct, seconds = 1)
  7: update.POSIXt(posct, seconds = 1)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1265204759, class = c("POSIXct", "POSIXt"), tzone = "GMT"), roll = FALSE, 
         week_start = 7, seconds = 1)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  12: as.POSIXct(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 1, dt = structure(1265204759, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  76. Error: update.POSIXt performs simple operation as expected (@test-update.R#73) 
  Invalid timezone of input vector: "GMT"
  1: expect_that(second(update(poslt, seconds = 1)), equals(1)) at testthat/test-update.R:73
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: second(update(poslt, seconds = 1))
  6: update(poslt, seconds = 1)
  7: update.POSIXt(poslt, seconds = 1)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 59, min = 45L, hour = 13L, mday = 3L, mon = 1L, year = 110L, 
         wday = 3L, yday = 33L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, seconds = 1)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 1, dt = structure(1265204759, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  77. Error: update.POSIXt works on wdays (@test-update.R#109) -------------------
  Invalid timezone of input vector: "America/New_York"
  1: expect_equal(wday(update(ct, wday = 1)), 1) at testthat/test-update.R:109
  2: compare(object, expected, ...)
  3: wday(update(ct, wday = 1))
  4: update(ct, wday = 1)
  5: update.POSIXt(ct, wday = 1)
  6: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  7: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1265222759, class = c("POSIXct", "POSIXt"), tzone = "America/New_York"), 
         roll = FALSE, week_start = 7, wday = 1)
  8: reclass_date(do.call(C_update_dt, updates), object)
  9: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  10: as.POSIXct(new)
  11: do.call(C_update_dt, updates)
  12: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = 1, 
         hour = integer(0), minute = integer(0), second = numeric(0), dt = structure(1265222759, class = c("POSIXct", 
         "POSIXt"), tzone = "America/New_York"), roll = FALSE, tz = "America/New_York", 
         week_start = 7)
  
  78. Error: updates on ydays works correctly with leap years (@test-update.R#157) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: expect_equal(update(ymd("15-02-03", tz = "America/New_York"), year = 2000, yday = 1), 
         ymd("2000-01-01", tz = "America/New_York")) at testthat/test-update.R:157
  2: compare(object, expected, ...)
  3: update(ymd("15-02-03", tz = "America/New_York"), year = 2000, yday = 1)
  4: ymd("15-02-03", tz = "America/New_York")
  5: .parse_xxx(..., orders = "ymd", quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  6: parse_date_time(dates, orders, quiet = quiet, tz = tz, locale = locale, truncated = truncated)
  7: .local_parse(x[to_parse], TRUE)
  8: .parse_date_time(x, formats, tz = tz, quiet = quiet, locale = locale)
  9: .strptime(x, formats[[1]], tz = tz, quiet = quiet, locale = locale)
  10: force_tz(out, tzone = tz)
  11: C_force_tz(time, tz = tzone, roll)
  
  79. Error: update performs roll overs correctly for POSIXlt objects (@test-update.R#199) 
  Invalid timezone of input vector: "GMT"
  1: expect_that(second(update(poslt, seconds = 61)), equals(1)) at testthat/test-update.R:199
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: second(update(poslt, seconds = 61))
  6: update(poslt, seconds = 61)
  7: update.POSIXt(poslt, seconds = 61)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 5L, mon = 4L, year = 110L, 
         wday = 3L, yday = 124L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, seconds = 61)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  12: as.POSIXlt(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 61, dt = structure(1273017600, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  80. Error: update performs roll overs correctly for POSIXct objects (@test-update.R#220) 
  Invalid timezone of input vector: "GMT"
  1: expect_that(second(update(posct, seconds = 61)), equals(1)) at testthat/test-update.R:220
  2: condition(object)
  3: expect_equal(x, expected, ..., expected.label = label)
  4: compare(object, expected, ...)
  5: second(update(posct, seconds = 61))
  6: update(posct, seconds = 61)
  7: update.POSIXt(posct, seconds = 61)
  8: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  9: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1273017600, class = c("POSIXct", "POSIXt"), tzone = "GMT"), roll = FALSE, 
         week_start = 7, seconds = 61)
  10: reclass_date(do.call(C_update_dt, updates), object)
  11: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  12: as.POSIXct(new)
  13: do.call(C_update_dt, updates)
  14: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = integer(0), yday = integer(0), mday = integer(0), wday = integer(0), 
         hour = integer(0), minute = integer(0), second = 61, dt = structure(1273017600, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  81. Error: update performs consecutive roll overs correctly for
    POSIXlt objects (@test-update.R#271) 
  Invalid timezone of input vector: "GMT"
  1: update(posl, months = 13, days = 32, hours = 25, minutes = 61, seconds = 61) at testthat/test-update.R:271
  2: update.POSIXt(posl, months = 13, days = 32, hours = 25, minutes = 61, seconds = 61)
  3: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  4: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(list(sec = 0, min = 0L, hour = 0L, mday = 1L, mon = 10L, year = 110L, 
         wday = 1L, yday = 304L, isdst = 0L), .Names = c("sec", "min", "hour", "mday", 
     "mon", "year", "wday", "yday", "isdst"), class = c("POSIXlt", "POSIXt"), tzone = "GMT"), 
         roll = FALSE, week_start = 7, months = 13, days = 32, hours = 25, minutes = 61, 
         seconds = 61)
  5: reclass_date(do.call(C_update_dt, updates), object)
  6: reclass_date.POSIXlt(do.call(C_update_dt, updates), object)
  7: as.POSIXlt(new)
  8: do.call(C_update_dt, updates)
  9: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = 13, yday = integer(0), mday = 32, wday = integer(0), 
         hour = 25, minute = 61, second = 61, dt = structure(1288569600, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  82. Error: update performs consecutive roll overs correctly for POSIXct objects (@test-update.R#301) 
  Invalid timezone of input vector: "GMT"
  1: update(posc, months = 13, days = 32, hours = 25, minutes = 61, seconds = 61) at testthat/test-update.R:301
  2: update.POSIXt(posc, months = 13, days = 32, hours = 25, minutes = 61, seconds = 61)
  3: do.call(update_date_time, c(list(object, roll = roll, week_start = week_start), list(...)))
  4: (function (object, years = integer(), months = integer(), days = integer(), mdays = integer(), 
         ydays = integer(), wdays = integer(), hours = integer(), minutes = integer(), 
         seconds = double(), tzs = NULL, roll = FALSE, week_start = 7) 
     {
         if (!length(object)) 
             return(object)
         if (length(days) > 0) 
             mdays = days
         updates <- list(year = years, month = months, yday = ydays, mday = mdays, wday = wdays, 
             hour = hours, minute = minutes, second = seconds)
         maxlen <- max(unlist(lapply(updates, length)))
         if (maxlen > 1) {
             for (nm in names(updates)) {
                 len <- length(updates[[nm]])
                 if (len != maxlen && len > 1) 
                     updates[[nm]] <- rep_len(updates[[nm]], maxlen)
             }
         }
         updates[["dt"]] <- as.POSIXct(object)
         updates[["roll"]] <- roll
         updates[["tz"]] <- if (is.null(tzs)) 
             tz(object)
         else tzs
         updates[["week_start"]] <- week_start
         reclass_date(do.call(C_update_dt, updates), object)
     })(structure(1288569600, class = c("POSIXct", "POSIXt"), tzone = "GMT"), roll = FALSE, 
         week_start = 7, months = 13, days = 32, hours = 25, minutes = 61, seconds = 61)
  5: reclass_date(do.call(C_update_dt, updates), object)
  6: reclass_date.POSIXct(do.call(C_update_dt, updates), object)
  7: as.POSIXct(new)
  8: do.call(C_update_dt, updates)
  9: (function (dt, year, month, yday, mday, wday, hour, minute, second, tz = NULL, roll = FALSE, 
         week_start = 7L) 
     {
         .Call(`_lubridate_C_update_dt`, dt, year, month, yday, mday, wday, hour, minute, 
             second, tz, roll, week_start)
     })(year = integer(0), month = 13, yday = integer(0), mday = 32, wday = integer(0), 
         hour = 25, minute = 61, second = 61, dt = structure(1288569600, class = c("POSIXct", 
         "POSIXt"), tzone = "GMT"), roll = FALSE, tz = "GMT", week_start = 7)
  
  83. Error: update returns NA for date-times in the spring dst gap (@test-update.R#330) 
  CCTZ: Unrecognized output timezone: "America/New_York"
  1: force_tz(poslt, tz = "America/New_York") at testthat/test-update.R:330
  2: C_force_tz(as.POSIXct(time, tz = tz(time)), tz = tzone, roll)
  
  testthat results ================================================================
  OK: 2453 SKIPPED: 2 FAILED: 83
  1. Error: converts character (@test-POSIXt.R#45) 
  2. Error: changes timezone of POSIXct (@test-POSIXt.R#49) 
  3. Error: isoweek returns correct value for non-UTC time zone (#311) (@test-accessors.R#195) 
  4. Error: force_tz returns NA for a time that falls in the spring gap (@test-daylight-savings.R#7) 
  5. Error: force_tz behaves consistently for the fall overlap (@test-daylight-savings.R#24) 
  6. Error: addition handles daylight savings time for spring gap (@test-daylight-savings.R#39) 
  7. Error: subtraction handles daylight savings time for spring gap (@test-daylight-savings.R#54) 
  8. Error: addition handles daylight savings time for fall overlap (@test-daylight-savings.R#68) 
  9. Error: subtraction handles daylight savings time for fall overlap (@test-daylight-savings.R#82) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted