Running ‘testthat.R’ [13s/17s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(coro)
  > 
  > test_check("coro")
  [ FAIL 2 | WARN 0 | SKIP 8 | PASS 200 ]
  
  ══ Skipped tests (8) ═══════════════════════════════════════════════════════════
  • On CRAN (3): 'test-async.R:25:1', 'test-generator.R:27:3',
    'test-generator.R:34:3'
  • Skipping (3): 'test-parser-block.R:63:3', 'test-parser-block.R:102:3',
    'test-parser-if.R:30:3'
  • reticulate cannot be loaded (2): 'test-iterator.R:2:3',
    'test-iterator.R:30:3'
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error ('test-async.R:18:3'): await() can't be called directly or out of place ──
  Error in `eval(quote({
      info <- machine_info(type, env = caller_env)
      if (is_null(state_machine)) {
          state_machine <<- walk_states(body(fn), info = info)
      }
      ops <- info$async_ops
      if (!is_null(ops) && !is_installed(ops$package)) {
          abort(sprintf("The %s package must be installed.", ops$package))
      }
      env <- new_generator_env(env, info)
      user_env <- env$user_env
      weak_env <- new_weakref(env)
      lapply(names(fmls), function(arg) env_bind_arg(user_env, 
          arg, frame = generator_env))
      undebugged <- FALSE
      instance <- inject(function(arg) {
          delayedAssign("arg", arg, assign.env = env)
          if (!undebugged && (debugged || is_true(peek_option("coro_debug")))) {
              env_browse(user_env)
              on.exit({
                  if (!env_is_browsed(user_env)) {
                    undebugged <<- TRUE
                  }
              }, add = TRUE)
          }
          if (is_true(env$jumped)) {
              if (!missing(arg)) {
                  force(arg)
              }
              abort("This function has been disabled because of an unexpected exit.")
          }
          if (is_true(env$exhausted)) {
              return(exhausted())
          }
          env$jumped <- TRUE
          out <- evalq(envir = user_env, base::evalq(envir = rlang::wref_key(!!weak_env), 
              {
                  env_poke_exits(user_env, exits)
                  !!state_machine
              }))
          env$jumped <- FALSE
          out
      })
      env$.self <- instance
      if (is_string(type, "async")) {
          invisible(instance(NULL))
      } else {
          structure(instance, class = "coro_generator_instance")
      }
  }), `_private`)`: The promises package must be installed.
  Backtrace:
       ▆
    1. ├─testthat::expect_error(f(), "within function arguments") at test-async.R:18:3
    2. │ └─testthat:::expect_condition_matching(...)
    3. │   └─testthat:::quasi_capture(...)
    4. │     ├─testthat (local) .capture(...)
    5. │     │ └─base::withCallingHandlers(...)
    6. │     └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    7. └─coro (local) f()
    8.   ├─base::local(...)
    9.   │ └─base::eval.parent(substitute(eval(quote(expr), envir)))
   10.   │   └─base::eval(expr, p)
   11.   │     └─base::eval(expr, p)
   12.   └─base::eval(...)
   13.     └─base::eval(...)
   14.       └─rlang::abort(sprintf("The %s package must be installed.", ops$package))
  ── Error ('test-step-reduce.R:112:3'): collect() preserves type (#32) ──────────
  <packageNotFoundError/error/condition>
  Error in `loadNamespace(x)`: there is no package called 'later'
  Backtrace:
      ▆
   1. ├─testthat::expect_equal(...) at test-step-reduce.R:112:3
   2. │ └─testthat::quasi_label(enquo(object), label, arg = "object")
   3. │   └─rlang::eval_bare(expr, quo_get_env(quo))
   4. ├─coro:::wait_for(async_collect(async_generator(function() for (i in 1:3) yield(i))()))
   5. └─base::loadNamespace(x)
   6.   └─base::withRestarts(stop(cond), retry_loadNamespace = function() NULL)
   7.     └─base (local) withOneRestart(expr, restarts[[1L]])
   8.       └─base (local) doWithOneRestart(return(expr), restart)
  
  [ FAIL 2 | WARN 0 | SKIP 8 | PASS 200 ]
  Error: Test failures
  Execution halted