CRAN Package Check Results for Package pkgcache

Last updated on 2019-08-19 22:47:12 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.0.5 9.58 54.69 64.27 OK
r-devel-linux-x86_64-debian-gcc 1.0.5 8.20 42.01 50.21 ERROR
r-devel-linux-x86_64-fedora-clang 1.0.5 77.29 OK
r-devel-linux-x86_64-fedora-gcc 1.0.5 76.21 OK
r-devel-windows-ix86+x86_64 1.0.5 25.00 86.00 111.00 OK
r-patched-linux-x86_64 1.0.5 10.24 54.57 64.81 OK
r-patched-solaris-x86 1.0.5 114.40 OK
r-release-linux-x86_64 1.0.5 9.85 53.74 63.59 OK
r-release-windows-ix86+x86_64 1.0.5 15.00 77.00 92.00 OK
r-release-osx-x86_64 1.0.5 OK
r-oldrel-windows-ix86+x86_64 1.0.5 16.00 111.00 127.00 OK
r-oldrel-osx-x86_64 1.0.5 OK

Check Details

Version: 1.0.5
Check: tests
Result: ERROR
     Running ‘test-async.R’ [5s/10s]
     Running ‘testthat.R’ [2s/4s]
    Running the tests in ‘tests/test-async.R’ failed.
    Complete output:
     >
     > if (file.exists("async")) {
     + library(testthat)
     + library(pkgcache)
     + test <- function() {
     + package <- "pkgcache"
     + env_test <- asNamespace("testthat")$env_test
     + env_test$in_test <- TRUE
     + env_test$package <- package
     + on.exit({
     + env_test$in_test <- FALSE
     + env_test$package <- NULL
     + })
     + test_path <- "async"
     + asNamespace("testthat")$test_package_dir(
     + package = package, test_path = test_path,
     + filter = NULL, reporter = "check")
     + }
     + test()
     + }
     ── 1. : when_any, multiple errors (@test-when-any.R#72) ───────────────────────
     conditionMessage\(reason\$errors\[\[1\]\]\) does not match "bar".
     Actual value: "foo"
    
     ── 2. Error: when_any, multiple errors (@test-when-any.R#72) ──────────────────
     no 'restart' 'continue_test' found
     1: synchronise(do()) at async/test-when-any.R:72
     2: stop(priv$value)
     3: (function (e)
     {
     handled <<- TRUE
     e$expectation_calls <- frame_calls(11, 6)
     register_expectation(e)
     invokeRestart("continue_test")
     })(structure(list(message = "conditionMessage\\(reason\\$errors\\[\\[1\\]\\]\\) does not match \"bar\".\nActual value: \"foo\"",
     srcref = NULL, aframe = list(frame = 47L, data = list(2545L, "parent", <environment>)),
     calls = pairlist(test(), asNamespace("testthat")$test_package_dir(package = package,
     test_path = test_path, filter = NULL, reporter = "check"), test_dir(path = test_path,
     reporter = reporter, env = env, filter = filter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap), test_files(paths, reporter = reporter,
     env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap), with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap)), force(code), lapply(paths, test_file,
     env = env, reporter = current_reporter, start_end_reporter = FALSE, load_helpers = FALSE,
     wrap = wrap), FUN(X[[i]], ...), with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     }), force(code), source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap), test_code(NULL,
     exprs, env), tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     }), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(tryCatchList(expr,
     names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]]), doTryCatch(return(expr),
     name, parentenv, handler), tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), tryCatchOne(expr,
     names, parentenv, handlers[[1L]]), doTryCatch(return(expr), name, parentenv,
     handler), withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), eval(code, test_env), eval(code,
     test_env), test_that("when_any, multiple errors", {
     do <- async(function() {
     d1 <- delay(1/100)$then(function(value) stop("foo"))
     d2 <- delay(1/10000)$then(function(value) stop("bar"))
     dx <- when_any(d1, d2)$catch(error = function(reason) {
     expect_match(conditionMessage(reason$errors[[1]]), "bar")
     expect_match(conditionMessage(reason$errors[[2]]), "foo")
     })
     })
     synchronise(do())
     }), test_code(desc, code, env = parent.frame()), tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     }), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(tryCatchList(expr,
     names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]]), doTryCatch(return(expr),
     name, parentenv, handler), tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), tryCatchOne(expr,
     names, parentenv, handlers[[1L]]), doTryCatch(return(expr), name, parentenv,
     handler), withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), eval(code, test_env), eval(code,
     test_env), synchronise(do()), new_el$run("once"), el_run(self, private, mode = match.arg(mode)), private$run_pending(), el__run_pending(self,
     private), call_with_callback(task$data$func, task$callback, info = task$data$error_info), tryCatch(withCallingHandlers(result <- func(),
     error = function(e) {
     recerror <<- e
     recerror$aframe <<- recerror$aframe %||% find_async_data_frame()
     recerror$calls <<- recerror$calls %||% sys.calls()
     recerror$parents <<- recerror$parents %||% sys.parents()
     recerror[names(info)] <<- info
     handler <- getOption("async.error")
     if (is.function(handler)) handler()
     }), error = identity), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(expr,
     names, parentenv, handlers[[1L]]), doTryCatch(return(expr), name, parentenv,
     handler), withCallingHandlers(result <- func(), error = function(e) {
     recerror <<- e
     recerror$aframe <<- recerror$aframe %||% find_async_data_frame()
     recerror$calls <<- recerror$calls %||% sys.calls()
     recerror$parents <<- recerror$parents %||% sys.parents()
     recerror[names(info)] <<- info
     handler <- getOption("async.error")
     if (is.function(handler)) handler()
     }), func(), private[[which]](value, private$resolve, id), stop(ret), (function (e)
     {
     recerror <<- e
     recerror$aframe <<- recerror$aframe %||% find_async_data_frame()
     recerror$calls <<- recerror$calls %||% sys.calls()
     recerror$parents <<- recerror$parents %||% sys.parents()
     recerror[names(info)] <<- info
     handler <- getOption("async.error")
     if (is.function(handler)) handler()
     })(structure(list(message = "conditionMessage\\(reason\\$errors\\[\\[1\\]\\]\\) does not match \"bar\".\nActual value: \"foo\"",
     srcref = NULL), class = c("expectation_failure", "expectation", "error",
     "condition")))), parents = c(0L, 1L, 2L, 3L, 4L, 5L, 4L, 7L, 8L, 9L, 8L, 11L,
     12L, 13L, 14L, 15L, 14L, 17L, 18L, 12L, 12L, 21L, 22L, 23L, 24L, 25L, 26L, 27L,
     26L, 29L, 30L, 24L, 24L, 33L, 34L, 35L, 36L, 37L, 38L, 39L, 40L, 41L, 42L, 43L,
     40L, 40L, 46L, 47L, 0L)), class = c("async_rejected", "expectation_failure",
     "expectation", "error", "condition")))
     4: invokeRestart("continue_test")
     5: stop(gettextf("no 'restart' '%s' found", as.character(r)), domain = NA)
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 644 | SKIPPED: 27 | WARNINGS: 3 | FAILED: 2 ]
     1. : when_any, multiple errors (@test-when-any.R#72)
     2. Error: when_any, multiple errors (@test-when-any.R#72)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc