Running ‘test-async.R’ [7s/11s]
  Running ‘testthat.R’ [3s/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, 
             {
                 lister$start_file(basename(path))
                 source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
                 end_context()
             }), 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 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