* using log directory 'd:/Rcompile/CRANpkg/local/4.5/future.mirai.Rcheck'
* using R Under development (unstable) (2024-06-21 r86808 ucrt)
* using platform: x86_64-w64-mingw32
* R was compiled by
    gcc.exe (GCC) 13.2.0
    GNU Fortran (GCC) 13.2.0
* running under: Windows Server 2022 x64 (build 20348)
* using session charset: UTF-8
* checking for file 'future.mirai/DESCRIPTION' ... OK
* this is package 'future.mirai' version '0.2.1'
* package encoding: UTF-8
* checking package namespace information ... OK
* checking package dependencies ... OK
* checking if this is a source package ... OK
* checking if there is a namespace ... OK
* checking for hidden files and directories ... OK
* checking for portable file names ... OK
* checking whether package 'future.mirai' can be installed ... OK
* checking installed package size ... OK
* checking package directory ... OK
* checking DESCRIPTION meta-information ... OK
* checking top-level files ... OK
* checking for left-over files ... OK
* checking index information ... OK
* checking package subdirectories ... OK
* checking code files for non-ASCII characters ... OK
* checking R files for syntax errors ... OK
* checking whether the package can be loaded ... [0s] OK
* checking whether the package can be loaded with stated dependencies ... [0s] OK
* checking whether the package can be unloaded cleanly ... [0s] OK
* checking whether the namespace can be loaded with stated dependencies ... [0s] OK
* checking whether the namespace can be unloaded cleanly ... [1s] OK
* checking loading without being on the library search path ... [0s] OK
* checking whether startup messages can be suppressed ... [1s] OK
* checking use of S3 registration ... OK
* checking dependencies in R code ... OK
* checking S3 generic/method consistency ... OK
* checking replacement functions ... OK
* checking foreign function calls ... OK
* checking R code for possible problems ... [3s] OK
* checking Rd files ... [0s] OK
* checking Rd metadata ... OK
* checking Rd cross-references ... OK
* checking for missing documentation entries ... OK
* checking for code/documentation mismatches ... OK
* checking Rd \usage sections ... OK
* checking Rd contents ... OK
* checking for unstated dependencies in examples ... OK
* checking examples ... [1s] ERROR
Running examples in 'future.mirai-Ex.R' failed
The error most likely occurred in:

> ### Name: mirai_cluster
> ### Title: Mirai-based cluster futures
> ### Aliases: mirai_cluster
> 
> ### ** Examples
> 
> mirai::daemons(parallelly::availableCores(), dispatcher = FALSE)
[1] 2
> plan(mirai_cluster)
Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
  R_ExternalPtrTag: argument of type NILSXP is not an external pointer
Calls: plan ... run.MiraiFuture -> do.call -> <Anonymous> -> request
Execution halted
* checking for unstated dependencies in 'tests' ... OK
* checking tests ... [21s] ERROR
  Running 'demo.R' [1s]
  Running 'dotdotdot.R' [1s]
  Running 'future,labels.R' [1s]
  Running 'future,lazy.R' [1s]
  Running 'future.tests,mirai_cluster.R' [3s]
  Running 'future.tests-mirai_multisession.R' [3s]
  Running 'globals,formulas.R' [1s]
  Running 'globals,manual.R' [1s]
  Running 'globals,nested.R' [1s]
  Running 'globals,subassignment.R' [1s]
  Running 'globals,tricky.R' [1s]
  Running 'mirai_cluster,worker-termination.R' [1s]
  Running 'mirai_cluster.R' [1s]
  Running 'nbrOfWorkers.R' [1s]
  Running 'plan.R' [1s]
  Running 'rng.R' [1s]
  Running 'stdout.R' [1s]
  Running 'zzz,future_lapply.R' [1s]
Running the tests in 'tests/demo.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:02.810] plan(): Setting new future strategy stack:
  [12:36:02.812] List of future strategies:
  [12:36:02.812] 1. mirai_multisession:
  [12:36:02.812]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:02.812]    - tweaked: FALSE
  [12:36:02.812]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:02.829] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:02.830] < mirai [$data] >
  [12:36:02.835] getGlobalsAndPackages() ...
  [12:36:02.835] Not searching for globals
  [12:36:02.836] - globals: [0] <none>
  [12:36:02.836] getGlobalsAndPackages() ... DONE
  [12:36:02.836] getGlobalsAndPackages() ...
  [12:36:02.836] 
  [12:36:02.837] - globals: [0] <none>
  [12:36:02.837] getGlobalsAndPackages() ... DONE
  [12:36:03.240] Packages needed by the future expression (n = 0): <none>
  [12:36:03.240] Packages needed by future strategies (n = 0): <none>
  [12:36:03.242] {
  [12:36:03.242]     {
  [12:36:03.242]         {
  [12:36:03.242]             ...future.startTime <- base::Sys.time()
  [12:36:03.242]             {
  [12:36:03.242]                 {
  [12:36:03.242]                   {
  [12:36:03.242]                     base::local({
  [12:36:03.242]                       has_future <- base::requireNamespace("future", 
  [12:36:03.242]                         quietly = TRUE)
  [12:36:03.242]                       if (has_future) {
  [12:36:03.242]                         ns <- base::getNamespace("future")
  [12:36:03.242]                         version <- ns[[".package"]][["version"]]
  [12:36:03.242]                         if (is.null(version)) 
  [12:36:03.242]                           version <- utils::packageVersion("future")
  [12:36:03.242]                       }
  [12:36:03.242]                       else {
  [12:36:03.242]                         version <- NULL
  [12:36:03.242]                       }
  [12:36:03.242]                       if (!has_future || version < "1.8.0") {
  [12:36:03.242]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:03.242]                           "", base::R.version$version.string), 
  [12:36:03.242]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:03.242]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:03.242]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:03.242]                             "release", "version")], collapse = " "), 
  [12:36:03.242]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:03.242]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:03.242]                           info)
  [12:36:03.242]                         info <- base::paste(info, collapse = "; ")
  [12:36:03.242]                         if (!has_future) {
  [12:36:03.242]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:03.242]                             info)
  [12:36:03.242]                         }
  [12:36:03.242]                         else {
  [12:36:03.242]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:03.242]                             info, version)
  [12:36:03.242]                         }
  [12:36:03.242]                         base::stop(msg)
  [12:36:03.242]                       }
  [12:36:03.242]                     })
  [12:36:03.242]                   }
  [12:36:03.242]                   ...future.strategy.old <- future::plan("list")
  [12:36:03.242]                   options(future.plan = NULL)
  [12:36:03.242]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:03.242]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:03.242]                 }
  [12:36:03.242]                 ...future.workdir <- getwd()
  [12:36:03.242]             }
  [12:36:03.242]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:03.242]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:03.242]         }
  [12:36:03.242]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:03.242]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:03.242]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:03.242]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:03.242]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:03.242]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:03.242]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:03.242]             base::names(...future.oldOptions))
  [12:36:03.242]     }
  [12:36:03.242]     if (FALSE) {
  [12:36:03.242]     }
  [12:36:03.242]     else {
  [12:36:03.242]         if (TRUE) {
  [12:36:03.242]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:03.242]                 open = "w")
  [12:36:03.242]         }
  [12:36:03.242]         else {
  [12:36:03.242]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:03.242]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:03.242]         }
  [12:36:03.242]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:03.242]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:03.242]             base::sink(type = "output", split = FALSE)
  [12:36:03.242]             base::close(...future.stdout)
  [12:36:03.242]         }, add = TRUE)
  [12:36:03.242]     }
  [12:36:03.242]     ...future.frame <- base::sys.nframe()
  [12:36:03.242]     ...future.conditions <- base::list()
  [12:36:03.242]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:03.242]     if (FALSE) {
  [12:36:03.242]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:03.242]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:03.242]     }
  [12:36:03.242]     ...future.result <- base::tryCatch({
  [12:36:03.242]         base::withCallingHandlers({
  [12:36:03.242]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:03.242]             future::FutureResult(value = ...future.value$value, 
  [12:36:03.242]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:03.242]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:03.242]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:03.242]                     ...future.globalenv.names))
  [12:36:03.242]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:03.242]         }, condition = base::local({
  [12:36:03.242]             c <- base::c
  [12:36:03.242]             inherits <- base::inherits
  [12:36:03.242]             invokeRestart <- base::invokeRestart
  [12:36:03.242]             length <- base::length
  [12:36:03.242]             list <- base::list
  [12:36:03.242]             seq.int <- base::seq.int
  [12:36:03.242]             signalCondition <- base::signalCondition
  [12:36:03.242]             sys.calls <- base::sys.calls
  [12:36:03.242]             `[[` <- base::`[[`
  [12:36:03.242]             `+` <- base::`+`
  [12:36:03.242]             `<<-` <- base::`<<-`
  [12:36:03.242]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:03.242]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:03.242]                   3L)]
  [12:36:03.242]             }
  [12:36:03.242]             function(cond) {
  [12:36:03.242]                 is_error <- inherits(cond, "error")
  [12:36:03.242]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:03.242]                   NULL)
  [12:36:03.242]                 if (is_error) {
  [12:36:03.242]                   sessionInformation <- function() {
  [12:36:03.242]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:03.242]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:03.242]                       search = base::search(), system = base::Sys.info())
  [12:36:03.242]                   }
  [12:36:03.242]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:03.242]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:03.242]                     cond$call), session = sessionInformation(), 
  [12:36:03.242]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:03.242]                   signalCondition(cond)
  [12:36:03.242]                 }
  [12:36:03.242]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:03.242]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:03.242]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:03.242]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:03.242]                   if (FALSE && !signal) {
  [12:36:03.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:03.242]                     {
  [12:36:03.242]                       inherits <- base::inherits
  [12:36:03.242]                       invokeRestart <- base::invokeRestart
  [12:36:03.242]                       is.null <- base::is.null
  [12:36:03.242]                       muffled <- FALSE
  [12:36:03.242]                       if (inherits(cond, "message")) {
  [12:36:03.242]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:03.242]                         if (muffled) 
  [12:36:03.242]                           invokeRestart("muffleMessage")
  [12:36:03.242]                       }
  [12:36:03.242]                       else if (inherits(cond, "warning")) {
  [12:36:03.242]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:03.242]                         if (muffled) 
  [12:36:03.242]                           invokeRestart("muffleWarning")
  [12:36:03.242]                       }
  [12:36:03.242]                       else if (inherits(cond, "condition")) {
  [12:36:03.242]                         if (!is.null(pattern)) {
  [12:36:03.242]                           computeRestarts <- base::computeRestarts
  [12:36:03.242]                           grepl <- base::grepl
  [12:36:03.242]                           restarts <- computeRestarts(cond)
  [12:36:03.242]                           for (restart in restarts) {
  [12:36:03.242]                             name <- restart$name
  [12:36:03.242]                             if (is.null(name)) 
  [12:36:03.242]                               next
  [12:36:03.242]                             if (!grepl(pattern, name)) 
  [12:36:03.242]                               next
  [12:36:03.242]                             invokeRestart(restart)
  [12:36:03.242]                             muffled <- TRUE
  [12:36:03.242]                             break
  [12:36:03.242]                           }
  [12:36:03.242]                         }
  [12:36:03.242]                       }
  [12:36:03.242]                       invisible(muffled)
  [12:36:03.242]                     }
  [12:36:03.242]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:03.242]                   }
  [12:36:03.242]                 }
  [12:36:03.242]                 else {
  [12:36:03.242]                   if (TRUE) {
  [12:36:03.242]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:03.242]                     {
  [12:36:03.242]                       inherits <- base::inherits
  [12:36:03.242]                       invokeRestart <- base::invokeRestart
  [12:36:03.242]                       is.null <- base::is.null
  [12:36:03.242]                       muffled <- FALSE
  [12:36:03.242]                       if (inherits(cond, "message")) {
  [12:36:03.242]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:03.242]                         if (muffled) 
  [12:36:03.242]                           invokeRestart("muffleMessage")
  [12:36:03.242]                       }
  [12:36:03.242]                       else if (inherits(cond, "warning")) {
  [12:36:03.242]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:03.242]                         if (muffled) 
  [12:36:03.242]                           invokeRestart("muffleWarning")
  [12:36:03.242]                       }
  [12:36:03.242]                       else if (inherits(cond, "condition")) {
  [12:36:03.242]                         if (!is.null(pattern)) {
  [12:36:03.242]                           computeRestarts <- base::computeRestarts
  [12:36:03.242]                           grepl <- base::grepl
  [12:36:03.242]                           restarts <- computeRestarts(cond)
  [12:36:03.242]                           for (restart in restarts) {
  [12:36:03.242]                             name <- restart$name
  [12:36:03.242]                             if (is.null(name)) 
  [12:36:03.242]                               next
  [12:36:03.242]                             if (!grepl(pattern, name)) 
  [12:36:03.242]                               next
  [12:36:03.242]                             invokeRestart(restart)
  [12:36:03.242]                             muffled <- TRUE
  [12:36:03.242]                             break
  [12:36:03.242]                           }
  [12:36:03.242]                         }
  [12:36:03.242]                       }
  [12:36:03.242]                       invisible(muffled)
  [12:36:03.242]                     }
  [12:36:03.242]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:03.242]                   }
  [12:36:03.242]                 }
  [12:36:03.242]             }
  [12:36:03.242]         }))
  [12:36:03.242]     }, error = function(ex) {
  [12:36:03.242]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:03.242]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:03.242]                 ...future.rng), started = ...future.startTime, 
  [12:36:03.242]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:03.242]             version = "1.8"), class = "FutureResult")
  [12:36:03.242]     }, finally = {
  [12:36:03.242]         if (!identical(...future.workdir, getwd())) 
  [12:36:03.242]             setwd(...future.workdir)
  [12:36:03.242]         {
  [12:36:03.242]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:03.242]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:03.242]             }
  [12:36:03.242]             base::options(...future.oldOptions)
  [12:36:03.242]             if (.Platform$OS.type == "windows") {
  [12:36:03.242]                 old_names <- names(...future.oldEnvVars)
  [12:36:03.242]                 envs <- base::Sys.getenv()
  [12:36:03.242]                 names <- names(envs)
  [12:36:03.242]                 common <- intersect(names, old_names)
  [12:36:03.242]                 added <- setdiff(names, old_names)
  [12:36:03.242]                 removed <- setdiff(old_names, names)
  [12:36:03.242]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:03.242]                   envs[common]]
  [12:36:03.242]                 NAMES <- toupper(changed)
  [12:36:03.242]                 args <- list()
  [12:36:03.242]                 for (kk in seq_along(NAMES)) {
  [12:36:03.242]                   name <- changed[[kk]]
  [12:36:03.242]                   NAME <- NAMES[[kk]]
  [12:36:03.242]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:03.242]                     next
  [12:36:03.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:03.242]                 }
  [12:36:03.242]                 NAMES <- toupper(added)
  [12:36:03.242]                 for (kk in seq_along(NAMES)) {
  [12:36:03.242]                   name <- added[[kk]]
  [12:36:03.242]                   NAME <- NAMES[[kk]]
  [12:36:03.242]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:03.242]                     next
  [12:36:03.242]                   args[[name]] <- ""
  [12:36:03.242]                 }
  [12:36:03.242]                 NAMES <- toupper(removed)
  [12:36:03.242]                 for (kk in seq_along(NAMES)) {
  [12:36:03.242]                   name <- removed[[kk]]
  [12:36:03.242]                   NAME <- NAMES[[kk]]
  [12:36:03.242]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:03.242]                     next
  [12:36:03.242]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:03.242]                 }
  [12:36:03.242]                 if (length(args) > 0) 
  [12:36:03.242]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:03.242]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:03.242]             }
  [12:36:03.242]             else {
  [12:36:03.242]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:03.242]             }
  [12:36:03.242]             {
  [12:36:03.242]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:03.242]                   0L) {
  [12:36:03.242]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:03.242]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:03.242]                   base::options(opts)
  [12:36:03.242]                 }
  [12:36:03.242]                 {
  [12:36:03.242]                   NULL
  [12:36:03.242]                   options(future.plan = NULL)
  [12:36:03.242]                   if (is.na(NA_character_)) 
  [12:36:03.242]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:03.242]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:03.242]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:03.242]                     .init = FALSE)
  [12:36:03.242]                 }
  [12:36:03.242]             }
  [12:36:03.242]         }
  [12:36:03.242]     })
  [12:36:03.242]     if (TRUE) {
  [12:36:03.242]         base::sink(type = "output", split = FALSE)
  [12:36:03.242]         if (TRUE) {
  [12:36:03.242]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:03.242]         }
  [12:36:03.242]         else {
  [12:36:03.242]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:03.242]         }
  [12:36:03.242]         base::close(...future.stdout)
  [12:36:03.242]         ...future.stdout <- NULL
  [12:36:03.242]     }
  [12:36:03.242]     ...future.result$conditions <- ...future.conditions
  [12:36:03.242]     ...future.result$finished <- base::Sys.time()
  [12:36:03.242]     ...future.result
  [12:36:03.242] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/dotdotdot.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:03.774] plan(): Setting new future strategy stack:
  [12:36:03.776] List of future strategies:
  [12:36:03.776] 1. mirai_multisession:
  [12:36:03.776]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:03.776]    - tweaked: FALSE
  [12:36:03.776]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:03.795] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:03.796] < mirai [$data] >
  [12:36:03.801] getGlobalsAndPackages() ...
  [12:36:03.801] Not searching for globals
  [12:36:03.802] - globals: [0] <none>
  [12:36:03.802] getGlobalsAndPackages() ... DONE
  [12:36:03.802] getGlobalsAndPackages() ...
  [12:36:03.802] 
  [12:36:03.803] - globals: [0] <none>
  [12:36:03.803] getGlobalsAndPackages() ... DONE
  [12:36:04.192] Packages needed by the future expression (n = 0): <none>
  [12:36:04.192] Packages needed by future strategies (n = 0): <none>
  [12:36:04.194] {
  [12:36:04.194]     {
  [12:36:04.194]         {
  [12:36:04.194]             ...future.startTime <- base::Sys.time()
  [12:36:04.194]             {
  [12:36:04.194]                 {
  [12:36:04.194]                   {
  [12:36:04.194]                     base::local({
  [12:36:04.194]                       has_future <- base::requireNamespace("future", 
  [12:36:04.194]                         quietly = TRUE)
  [12:36:04.194]                       if (has_future) {
  [12:36:04.194]                         ns <- base::getNamespace("future")
  [12:36:04.194]                         version <- ns[[".package"]][["version"]]
  [12:36:04.194]                         if (is.null(version)) 
  [12:36:04.194]                           version <- utils::packageVersion("future")
  [12:36:04.194]                       }
  [12:36:04.194]                       else {
  [12:36:04.194]                         version <- NULL
  [12:36:04.194]                       }
  [12:36:04.194]                       if (!has_future || version < "1.8.0") {
  [12:36:04.194]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:04.194]                           "", base::R.version$version.string), 
  [12:36:04.194]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:04.194]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:04.194]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:04.194]                             "release", "version")], collapse = " "), 
  [12:36:04.194]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:04.194]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:04.194]                           info)
  [12:36:04.194]                         info <- base::paste(info, collapse = "; ")
  [12:36:04.194]                         if (!has_future) {
  [12:36:04.194]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:04.194]                             info)
  [12:36:04.194]                         }
  [12:36:04.194]                         else {
  [12:36:04.194]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:04.194]                             info, version)
  [12:36:04.194]                         }
  [12:36:04.194]                         base::stop(msg)
  [12:36:04.194]                       }
  [12:36:04.194]                     })
  [12:36:04.194]                   }
  [12:36:04.194]                   ...future.strategy.old <- future::plan("list")
  [12:36:04.194]                   options(future.plan = NULL)
  [12:36:04.194]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:04.194]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:04.194]                 }
  [12:36:04.194]                 ...future.workdir <- getwd()
  [12:36:04.194]             }
  [12:36:04.194]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:04.194]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:04.194]         }
  [12:36:04.194]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:04.194]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:04.194]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:04.194]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:04.194]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:04.194]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:04.194]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:04.194]             base::names(...future.oldOptions))
  [12:36:04.194]     }
  [12:36:04.194]     if (FALSE) {
  [12:36:04.194]     }
  [12:36:04.194]     else {
  [12:36:04.194]         if (TRUE) {
  [12:36:04.194]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:04.194]                 open = "w")
  [12:36:04.194]         }
  [12:36:04.194]         else {
  [12:36:04.194]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:04.194]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:04.194]         }
  [12:36:04.194]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:04.194]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:04.194]             base::sink(type = "output", split = FALSE)
  [12:36:04.194]             base::close(...future.stdout)
  [12:36:04.194]         }, add = TRUE)
  [12:36:04.194]     }
  [12:36:04.194]     ...future.frame <- base::sys.nframe()
  [12:36:04.194]     ...future.conditions <- base::list()
  [12:36:04.194]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:04.194]     if (FALSE) {
  [12:36:04.194]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:04.194]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:04.194]     }
  [12:36:04.194]     ...future.result <- base::tryCatch({
  [12:36:04.194]         base::withCallingHandlers({
  [12:36:04.194]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:04.194]             future::FutureResult(value = ...future.value$value, 
  [12:36:04.194]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:04.194]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:04.194]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:04.194]                     ...future.globalenv.names))
  [12:36:04.194]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:04.194]         }, condition = base::local({
  [12:36:04.194]             c <- base::c
  [12:36:04.194]             inherits <- base::inherits
  [12:36:04.194]             invokeRestart <- base::invokeRestart
  [12:36:04.194]             length <- base::length
  [12:36:04.194]             list <- base::list
  [12:36:04.194]             seq.int <- base::seq.int
  [12:36:04.194]             signalCondition <- base::signalCondition
  [12:36:04.194]             sys.calls <- base::sys.calls
  [12:36:04.194]             `[[` <- base::`[[`
  [12:36:04.194]             `+` <- base::`+`
  [12:36:04.194]             `<<-` <- base::`<<-`
  [12:36:04.194]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:04.194]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:04.194]                   3L)]
  [12:36:04.194]             }
  [12:36:04.194]             function(cond) {
  [12:36:04.194]                 is_error <- inherits(cond, "error")
  [12:36:04.194]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:04.194]                   NULL)
  [12:36:04.194]                 if (is_error) {
  [12:36:04.194]                   sessionInformation <- function() {
  [12:36:04.194]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:04.194]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:04.194]                       search = base::search(), system = base::Sys.info())
  [12:36:04.194]                   }
  [12:36:04.194]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:04.194]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:04.194]                     cond$call), session = sessionInformation(), 
  [12:36:04.194]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:04.194]                   signalCondition(cond)
  [12:36:04.194]                 }
  [12:36:04.194]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:04.194]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:04.194]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:04.194]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:04.194]                   if (FALSE && !signal) {
  [12:36:04.194]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:04.194]                     {
  [12:36:04.194]                       inherits <- base::inherits
  [12:36:04.194]                       invokeRestart <- base::invokeRestart
  [12:36:04.194]                       is.null <- base::is.null
  [12:36:04.194]                       muffled <- FALSE
  [12:36:04.194]                       if (inherits(cond, "message")) {
  [12:36:04.194]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:04.194]                         if (muffled) 
  [12:36:04.194]                           invokeRestart("muffleMessage")
  [12:36:04.194]                       }
  [12:36:04.194]                       else if (inherits(cond, "warning")) {
  [12:36:04.194]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:04.194]                         if (muffled) 
  [12:36:04.194]                           invokeRestart("muffleWarning")
  [12:36:04.194]                       }
  [12:36:04.194]                       else if (inherits(cond, "condition")) {
  [12:36:04.194]                         if (!is.null(pattern)) {
  [12:36:04.194]                           computeRestarts <- base::computeRestarts
  [12:36:04.194]                           grepl <- base::grepl
  [12:36:04.194]                           restarts <- computeRestarts(cond)
  [12:36:04.194]                           for (restart in restarts) {
  [12:36:04.194]                             name <- restart$name
  [12:36:04.194]                             if (is.null(name)) 
  [12:36:04.194]                               next
  [12:36:04.194]                             if (!grepl(pattern, name)) 
  [12:36:04.194]                               next
  [12:36:04.194]                             invokeRestart(restart)
  [12:36:04.194]                             muffled <- TRUE
  [12:36:04.194]                             break
  [12:36:04.194]                           }
  [12:36:04.194]                         }
  [12:36:04.194]                       }
  [12:36:04.194]                       invisible(muffled)
  [12:36:04.194]                     }
  [12:36:04.194]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:04.194]                   }
  [12:36:04.194]                 }
  [12:36:04.194]                 else {
  [12:36:04.194]                   if (TRUE) {
  [12:36:04.194]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:04.194]                     {
  [12:36:04.194]                       inherits <- base::inherits
  [12:36:04.194]                       invokeRestart <- base::invokeRestart
  [12:36:04.194]                       is.null <- base::is.null
  [12:36:04.194]                       muffled <- FALSE
  [12:36:04.194]                       if (inherits(cond, "message")) {
  [12:36:04.194]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:04.194]                         if (muffled) 
  [12:36:04.194]                           invokeRestart("muffleMessage")
  [12:36:04.194]                       }
  [12:36:04.194]                       else if (inherits(cond, "warning")) {
  [12:36:04.194]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:04.194]                         if (muffled) 
  [12:36:04.194]                           invokeRestart("muffleWarning")
  [12:36:04.194]                       }
  [12:36:04.194]                       else if (inherits(cond, "condition")) {
  [12:36:04.194]                         if (!is.null(pattern)) {
  [12:36:04.194]                           computeRestarts <- base::computeRestarts
  [12:36:04.194]                           grepl <- base::grepl
  [12:36:04.194]                           restarts <- computeRestarts(cond)
  [12:36:04.194]                           for (restart in restarts) {
  [12:36:04.194]                             name <- restart$name
  [12:36:04.194]                             if (is.null(name)) 
  [12:36:04.194]                               next
  [12:36:04.194]                             if (!grepl(pattern, name)) 
  [12:36:04.194]                               next
  [12:36:04.194]                             invokeRestart(restart)
  [12:36:04.194]                             muffled <- TRUE
  [12:36:04.194]                             break
  [12:36:04.194]                           }
  [12:36:04.194]                         }
  [12:36:04.194]                       }
  [12:36:04.194]                       invisible(muffled)
  [12:36:04.194]                     }
  [12:36:04.194]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:04.194]                   }
  [12:36:04.194]                 }
  [12:36:04.194]             }
  [12:36:04.194]         }))
  [12:36:04.194]     }, error = function(ex) {
  [12:36:04.194]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:04.194]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:04.194]                 ...future.rng), started = ...future.startTime, 
  [12:36:04.194]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:04.194]             version = "1.8"), class = "FutureResult")
  [12:36:04.194]     }, finally = {
  [12:36:04.194]         if (!identical(...future.workdir, getwd())) 
  [12:36:04.194]             setwd(...future.workdir)
  [12:36:04.194]         {
  [12:36:04.194]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:04.194]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:04.194]             }
  [12:36:04.194]             base::options(...future.oldOptions)
  [12:36:04.194]             if (.Platform$OS.type == "windows") {
  [12:36:04.194]                 old_names <- names(...future.oldEnvVars)
  [12:36:04.194]                 envs <- base::Sys.getenv()
  [12:36:04.194]                 names <- names(envs)
  [12:36:04.194]                 common <- intersect(names, old_names)
  [12:36:04.194]                 added <- setdiff(names, old_names)
  [12:36:04.194]                 removed <- setdiff(old_names, names)
  [12:36:04.194]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:04.194]                   envs[common]]
  [12:36:04.194]                 NAMES <- toupper(changed)
  [12:36:04.194]                 args <- list()
  [12:36:04.194]                 for (kk in seq_along(NAMES)) {
  [12:36:04.194]                   name <- changed[[kk]]
  [12:36:04.194]                   NAME <- NAMES[[kk]]
  [12:36:04.194]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:04.194]                     next
  [12:36:04.194]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:04.194]                 }
  [12:36:04.194]                 NAMES <- toupper(added)
  [12:36:04.194]                 for (kk in seq_along(NAMES)) {
  [12:36:04.194]                   name <- added[[kk]]
  [12:36:04.194]                   NAME <- NAMES[[kk]]
  [12:36:04.194]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:04.194]                     next
  [12:36:04.194]                   args[[name]] <- ""
  [12:36:04.194]                 }
  [12:36:04.194]                 NAMES <- toupper(removed)
  [12:36:04.194]                 for (kk in seq_along(NAMES)) {
  [12:36:04.194]                   name <- removed[[kk]]
  [12:36:04.194]                   NAME <- NAMES[[kk]]
  [12:36:04.194]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:04.194]                     next
  [12:36:04.194]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:04.194]                 }
  [12:36:04.194]                 if (length(args) > 0) 
  [12:36:04.194]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:04.194]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:04.194]             }
  [12:36:04.194]             else {
  [12:36:04.194]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:04.194]             }
  [12:36:04.194]             {
  [12:36:04.194]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:04.194]                   0L) {
  [12:36:04.194]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:04.194]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:04.194]                   base::options(opts)
  [12:36:04.194]                 }
  [12:36:04.194]                 {
  [12:36:04.194]                   NULL
  [12:36:04.194]                   options(future.plan = NULL)
  [12:36:04.194]                   if (is.na(NA_character_)) 
  [12:36:04.194]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:04.194]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:04.194]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:04.194]                     .init = FALSE)
  [12:36:04.194]                 }
  [12:36:04.194]             }
  [12:36:04.194]         }
  [12:36:04.194]     })
  [12:36:04.194]     if (TRUE) {
  [12:36:04.194]         base::sink(type = "output", split = FALSE)
  [12:36:04.194]         if (TRUE) {
  [12:36:04.194]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:04.194]         }
  [12:36:04.194]         else {
  [12:36:04.194]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:04.194]         }
  [12:36:04.194]         base::close(...future.stdout)
  [12:36:04.194]         ...future.stdout <- NULL
  [12:36:04.194]     }
  [12:36:04.194]     ...future.result$conditions <- ...future.conditions
  [12:36:04.194]     ...future.result$finished <- base::Sys.time()
  [12:36:04.194]     ...future.result
  [12:36:04.194] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/future,labels.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:04.801] plan(): Setting new future strategy stack:
  [12:36:04.803] List of future strategies:
  [12:36:04.803] 1. mirai_multisession:
  [12:36:04.803]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:04.803]    - tweaked: FALSE
  [12:36:04.803]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:04.825] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:04.825] < mirai [$data] >
  [12:36:04.839] getGlobalsAndPackages() ...
  [12:36:04.840] Not searching for globals
  [12:36:04.840] - globals: [0] <none>
  [12:36:04.840] getGlobalsAndPackages() ... DONE
  [12:36:04.841] getGlobalsAndPackages() ...
  [12:36:04.841] 
  [12:36:04.841] - globals: [0] <none>
  [12:36:04.842] getGlobalsAndPackages() ... DONE
  [12:36:05.255] Packages needed by the future expression (n = 0): <none>
  [12:36:05.255] Packages needed by future strategies (n = 0): <none>
  [12:36:05.256] {
  [12:36:05.256]     {
  [12:36:05.256]         {
  [12:36:05.256]             ...future.startTime <- base::Sys.time()
  [12:36:05.256]             {
  [12:36:05.256]                 {
  [12:36:05.256]                   {
  [12:36:05.256]                     base::local({
  [12:36:05.256]                       has_future <- base::requireNamespace("future", 
  [12:36:05.256]                         quietly = TRUE)
  [12:36:05.256]                       if (has_future) {
  [12:36:05.256]                         ns <- base::getNamespace("future")
  [12:36:05.256]                         version <- ns[[".package"]][["version"]]
  [12:36:05.256]                         if (is.null(version)) 
  [12:36:05.256]                           version <- utils::packageVersion("future")
  [12:36:05.256]                       }
  [12:36:05.256]                       else {
  [12:36:05.256]                         version <- NULL
  [12:36:05.256]                       }
  [12:36:05.256]                       if (!has_future || version < "1.8.0") {
  [12:36:05.256]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:05.256]                           "", base::R.version$version.string), 
  [12:36:05.256]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:05.256]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:05.256]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:05.256]                             "release", "version")], collapse = " "), 
  [12:36:05.256]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:05.256]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:05.256]                           info)
  [12:36:05.256]                         info <- base::paste(info, collapse = "; ")
  [12:36:05.256]                         if (!has_future) {
  [12:36:05.256]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:05.256]                             info)
  [12:36:05.256]                         }
  [12:36:05.256]                         else {
  [12:36:05.256]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:05.256]                             info, version)
  [12:36:05.256]                         }
  [12:36:05.256]                         base::stop(msg)
  [12:36:05.256]                       }
  [12:36:05.256]                     })
  [12:36:05.256]                   }
  [12:36:05.256]                   ...future.strategy.old <- future::plan("list")
  [12:36:05.256]                   options(future.plan = NULL)
  [12:36:05.256]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:05.256]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:05.256]                 }
  [12:36:05.256]                 ...future.workdir <- getwd()
  [12:36:05.256]             }
  [12:36:05.256]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:05.256]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:05.256]         }
  [12:36:05.256]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:05.256]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:05.256]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:05.256]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:05.256]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:05.256]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:05.256]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:05.256]             base::names(...future.oldOptions))
  [12:36:05.256]     }
  [12:36:05.256]     if (FALSE) {
  [12:36:05.256]     }
  [12:36:05.256]     else {
  [12:36:05.256]         if (TRUE) {
  [12:36:05.256]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:05.256]                 open = "w")
  [12:36:05.256]         }
  [12:36:05.256]         else {
  [12:36:05.256]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:05.256]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:05.256]         }
  [12:36:05.256]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:05.256]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:05.256]             base::sink(type = "output", split = FALSE)
  [12:36:05.256]             base::close(...future.stdout)
  [12:36:05.256]         }, add = TRUE)
  [12:36:05.256]     }
  [12:36:05.256]     ...future.frame <- base::sys.nframe()
  [12:36:05.256]     ...future.conditions <- base::list()
  [12:36:05.256]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:05.256]     if (FALSE) {
  [12:36:05.256]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:05.256]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:05.256]     }
  [12:36:05.256]     ...future.result <- base::tryCatch({
  [12:36:05.256]         base::withCallingHandlers({
  [12:36:05.256]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:05.256]             future::FutureResult(value = ...future.value$value, 
  [12:36:05.256]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:05.256]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:05.256]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:05.256]                     ...future.globalenv.names))
  [12:36:05.256]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:05.256]         }, condition = base::local({
  [12:36:05.256]             c <- base::c
  [12:36:05.256]             inherits <- base::inherits
  [12:36:05.256]             invokeRestart <- base::invokeRestart
  [12:36:05.256]             length <- base::length
  [12:36:05.256]             list <- base::list
  [12:36:05.256]             seq.int <- base::seq.int
  [12:36:05.256]             signalCondition <- base::signalCondition
  [12:36:05.256]             sys.calls <- base::sys.calls
  [12:36:05.256]             `[[` <- base::`[[`
  [12:36:05.256]             `+` <- base::`+`
  [12:36:05.256]             `<<-` <- base::`<<-`
  [12:36:05.256]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:05.256]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:05.256]                   3L)]
  [12:36:05.256]             }
  [12:36:05.256]             function(cond) {
  [12:36:05.256]                 is_error <- inherits(cond, "error")
  [12:36:05.256]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:05.256]                   NULL)
  [12:36:05.256]                 if (is_error) {
  [12:36:05.256]                   sessionInformation <- function() {
  [12:36:05.256]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:05.256]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:05.256]                       search = base::search(), system = base::Sys.info())
  [12:36:05.256]                   }
  [12:36:05.256]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:05.256]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:05.256]                     cond$call), session = sessionInformation(), 
  [12:36:05.256]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:05.256]                   signalCondition(cond)
  [12:36:05.256]                 }
  [12:36:05.256]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:05.256]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:05.256]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:05.256]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:05.256]                   if (FALSE && !signal) {
  [12:36:05.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:05.256]                     {
  [12:36:05.256]                       inherits <- base::inherits
  [12:36:05.256]                       invokeRestart <- base::invokeRestart
  [12:36:05.256]                       is.null <- base::is.null
  [12:36:05.256]                       muffled <- FALSE
  [12:36:05.256]                       if (inherits(cond, "message")) {
  [12:36:05.256]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:05.256]                         if (muffled) 
  [12:36:05.256]                           invokeRestart("muffleMessage")
  [12:36:05.256]                       }
  [12:36:05.256]                       else if (inherits(cond, "warning")) {
  [12:36:05.256]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:05.256]                         if (muffled) 
  [12:36:05.256]                           invokeRestart("muffleWarning")
  [12:36:05.256]                       }
  [12:36:05.256]                       else if (inherits(cond, "condition")) {
  [12:36:05.256]                         if (!is.null(pattern)) {
  [12:36:05.256]                           computeRestarts <- base::computeRestarts
  [12:36:05.256]                           grepl <- base::grepl
  [12:36:05.256]                           restarts <- computeRestarts(cond)
  [12:36:05.256]                           for (restart in restarts) {
  [12:36:05.256]                             name <- restart$name
  [12:36:05.256]                             if (is.null(name)) 
  [12:36:05.256]                               next
  [12:36:05.256]                             if (!grepl(pattern, name)) 
  [12:36:05.256]                               next
  [12:36:05.256]                             invokeRestart(restart)
  [12:36:05.256]                             muffled <- TRUE
  [12:36:05.256]                             break
  [12:36:05.256]                           }
  [12:36:05.256]                         }
  [12:36:05.256]                       }
  [12:36:05.256]                       invisible(muffled)
  [12:36:05.256]                     }
  [12:36:05.256]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:05.256]                   }
  [12:36:05.256]                 }
  [12:36:05.256]                 else {
  [12:36:05.256]                   if (TRUE) {
  [12:36:05.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:05.256]                     {
  [12:36:05.256]                       inherits <- base::inherits
  [12:36:05.256]                       invokeRestart <- base::invokeRestart
  [12:36:05.256]                       is.null <- base::is.null
  [12:36:05.256]                       muffled <- FALSE
  [12:36:05.256]                       if (inherits(cond, "message")) {
  [12:36:05.256]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:05.256]                         if (muffled) 
  [12:36:05.256]                           invokeRestart("muffleMessage")
  [12:36:05.256]                       }
  [12:36:05.256]                       else if (inherits(cond, "warning")) {
  [12:36:05.256]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:05.256]                         if (muffled) 
  [12:36:05.256]                           invokeRestart("muffleWarning")
  [12:36:05.256]                       }
  [12:36:05.256]                       else if (inherits(cond, "condition")) {
  [12:36:05.256]                         if (!is.null(pattern)) {
  [12:36:05.256]                           computeRestarts <- base::computeRestarts
  [12:36:05.256]                           grepl <- base::grepl
  [12:36:05.256]                           restarts <- computeRestarts(cond)
  [12:36:05.256]                           for (restart in restarts) {
  [12:36:05.256]                             name <- restart$name
  [12:36:05.256]                             if (is.null(name)) 
  [12:36:05.256]                               next
  [12:36:05.256]                             if (!grepl(pattern, name)) 
  [12:36:05.256]                               next
  [12:36:05.256]                             invokeRestart(restart)
  [12:36:05.256]                             muffled <- TRUE
  [12:36:05.256]                             break
  [12:36:05.256]                           }
  [12:36:05.256]                         }
  [12:36:05.256]                       }
  [12:36:05.256]                       invisible(muffled)
  [12:36:05.256]                     }
  [12:36:05.256]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:05.256]                   }
  [12:36:05.256]                 }
  [12:36:05.256]             }
  [12:36:05.256]         }))
  [12:36:05.256]     }, error = function(ex) {
  [12:36:05.256]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:05.256]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:05.256]                 ...future.rng), started = ...future.startTime, 
  [12:36:05.256]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:05.256]             version = "1.8"), class = "FutureResult")
  [12:36:05.256]     }, finally = {
  [12:36:05.256]         if (!identical(...future.workdir, getwd())) 
  [12:36:05.256]             setwd(...future.workdir)
  [12:36:05.256]         {
  [12:36:05.256]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:05.256]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:05.256]             }
  [12:36:05.256]             base::options(...future.oldOptions)
  [12:36:05.256]             if (.Platform$OS.type == "windows") {
  [12:36:05.256]                 old_names <- names(...future.oldEnvVars)
  [12:36:05.256]                 envs <- base::Sys.getenv()
  [12:36:05.256]                 names <- names(envs)
  [12:36:05.256]                 common <- intersect(names, old_names)
  [12:36:05.256]                 added <- setdiff(names, old_names)
  [12:36:05.256]                 removed <- setdiff(old_names, names)
  [12:36:05.256]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:05.256]                   envs[common]]
  [12:36:05.256]                 NAMES <- toupper(changed)
  [12:36:05.256]                 args <- list()
  [12:36:05.256]                 for (kk in seq_along(NAMES)) {
  [12:36:05.256]                   name <- changed[[kk]]
  [12:36:05.256]                   NAME <- NAMES[[kk]]
  [12:36:05.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:05.256]                     next
  [12:36:05.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:05.256]                 }
  [12:36:05.256]                 NAMES <- toupper(added)
  [12:36:05.256]                 for (kk in seq_along(NAMES)) {
  [12:36:05.256]                   name <- added[[kk]]
  [12:36:05.256]                   NAME <- NAMES[[kk]]
  [12:36:05.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:05.256]                     next
  [12:36:05.256]                   args[[name]] <- ""
  [12:36:05.256]                 }
  [12:36:05.256]                 NAMES <- toupper(removed)
  [12:36:05.256]                 for (kk in seq_along(NAMES)) {
  [12:36:05.256]                   name <- removed[[kk]]
  [12:36:05.256]                   NAME <- NAMES[[kk]]
  [12:36:05.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:05.256]                     next
  [12:36:05.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:05.256]                 }
  [12:36:05.256]                 if (length(args) > 0) 
  [12:36:05.256]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:05.256]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:05.256]             }
  [12:36:05.256]             else {
  [12:36:05.256]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:05.256]             }
  [12:36:05.256]             {
  [12:36:05.256]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:05.256]                   0L) {
  [12:36:05.256]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:05.256]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:05.256]                   base::options(opts)
  [12:36:05.256]                 }
  [12:36:05.256]                 {
  [12:36:05.256]                   NULL
  [12:36:05.256]                   options(future.plan = NULL)
  [12:36:05.256]                   if (is.na(NA_character_)) 
  [12:36:05.256]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:05.256]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:05.256]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:05.256]                     .init = FALSE)
  [12:36:05.256]                 }
  [12:36:05.256]             }
  [12:36:05.256]         }
  [12:36:05.256]     })
  [12:36:05.256]     if (TRUE) {
  [12:36:05.256]         base::sink(type = "output", split = FALSE)
  [12:36:05.256]         if (TRUE) {
  [12:36:05.256]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:05.256]         }
  [12:36:05.256]         else {
  [12:36:05.256]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:05.256]         }
  [12:36:05.256]         base::close(...future.stdout)
  [12:36:05.256]         ...future.stdout <- NULL
  [12:36:05.256]     }
  [12:36:05.256]     ...future.result$conditions <- ...future.conditions
  [12:36:05.256]     ...future.result$finished <- base::Sys.time()
  [12:36:05.256]     ...future.result
  [12:36:05.256] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/future,lazy.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:05.792] plan(): Setting new future strategy stack:
  [12:36:05.793] List of future strategies:
  [12:36:05.793] 1. mirai_multisession:
  [12:36:05.793]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:05.793]    - tweaked: FALSE
  [12:36:05.793]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:05.808] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:05.808] < mirai [$data] >
  [12:36:05.814] getGlobalsAndPackages() ...
  [12:36:05.815] Not searching for globals
  [12:36:05.815] - globals: [0] <none>
  [12:36:05.815] getGlobalsAndPackages() ... DONE
  [12:36:05.816] getGlobalsAndPackages() ...
  [12:36:05.816] 
  [12:36:05.816] - globals: [0] <none>
  [12:36:05.816] getGlobalsAndPackages() ... DONE
  [12:36:06.254] Packages needed by the future expression (n = 0): <none>
  [12:36:06.255] Packages needed by future strategies (n = 0): <none>
  [12:36:06.256] {
  [12:36:06.256]     {
  [12:36:06.256]         {
  [12:36:06.256]             ...future.startTime <- base::Sys.time()
  [12:36:06.256]             {
  [12:36:06.256]                 {
  [12:36:06.256]                   {
  [12:36:06.256]                     base::local({
  [12:36:06.256]                       has_future <- base::requireNamespace("future", 
  [12:36:06.256]                         quietly = TRUE)
  [12:36:06.256]                       if (has_future) {
  [12:36:06.256]                         ns <- base::getNamespace("future")
  [12:36:06.256]                         version <- ns[[".package"]][["version"]]
  [12:36:06.256]                         if (is.null(version)) 
  [12:36:06.256]                           version <- utils::packageVersion("future")
  [12:36:06.256]                       }
  [12:36:06.256]                       else {
  [12:36:06.256]                         version <- NULL
  [12:36:06.256]                       }
  [12:36:06.256]                       if (!has_future || version < "1.8.0") {
  [12:36:06.256]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:06.256]                           "", base::R.version$version.string), 
  [12:36:06.256]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:06.256]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:06.256]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:06.256]                             "release", "version")], collapse = " "), 
  [12:36:06.256]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:06.256]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:06.256]                           info)
  [12:36:06.256]                         info <- base::paste(info, collapse = "; ")
  [12:36:06.256]                         if (!has_future) {
  [12:36:06.256]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:06.256]                             info)
  [12:36:06.256]                         }
  [12:36:06.256]                         else {
  [12:36:06.256]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:06.256]                             info, version)
  [12:36:06.256]                         }
  [12:36:06.256]                         base::stop(msg)
  [12:36:06.256]                       }
  [12:36:06.256]                     })
  [12:36:06.256]                   }
  [12:36:06.256]                   ...future.strategy.old <- future::plan("list")
  [12:36:06.256]                   options(future.plan = NULL)
  [12:36:06.256]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:06.256]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:06.256]                 }
  [12:36:06.256]                 ...future.workdir <- getwd()
  [12:36:06.256]             }
  [12:36:06.256]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:06.256]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:06.256]         }
  [12:36:06.256]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:06.256]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:06.256]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:06.256]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:06.256]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:06.256]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:06.256]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:06.256]             base::names(...future.oldOptions))
  [12:36:06.256]     }
  [12:36:06.256]     if (FALSE) {
  [12:36:06.256]     }
  [12:36:06.256]     else {
  [12:36:06.256]         if (TRUE) {
  [12:36:06.256]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:06.256]                 open = "w")
  [12:36:06.256]         }
  [12:36:06.256]         else {
  [12:36:06.256]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:06.256]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:06.256]         }
  [12:36:06.256]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:06.256]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:06.256]             base::sink(type = "output", split = FALSE)
  [12:36:06.256]             base::close(...future.stdout)
  [12:36:06.256]         }, add = TRUE)
  [12:36:06.256]     }
  [12:36:06.256]     ...future.frame <- base::sys.nframe()
  [12:36:06.256]     ...future.conditions <- base::list()
  [12:36:06.256]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:06.256]     if (FALSE) {
  [12:36:06.256]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:06.256]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:06.256]     }
  [12:36:06.256]     ...future.result <- base::tryCatch({
  [12:36:06.256]         base::withCallingHandlers({
  [12:36:06.256]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:06.256]             future::FutureResult(value = ...future.value$value, 
  [12:36:06.256]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:06.256]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:06.256]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:06.256]                     ...future.globalenv.names))
  [12:36:06.256]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:06.256]         }, condition = base::local({
  [12:36:06.256]             c <- base::c
  [12:36:06.256]             inherits <- base::inherits
  [12:36:06.256]             invokeRestart <- base::invokeRestart
  [12:36:06.256]             length <- base::length
  [12:36:06.256]             list <- base::list
  [12:36:06.256]             seq.int <- base::seq.int
  [12:36:06.256]             signalCondition <- base::signalCondition
  [12:36:06.256]             sys.calls <- base::sys.calls
  [12:36:06.256]             `[[` <- base::`[[`
  [12:36:06.256]             `+` <- base::`+`
  [12:36:06.256]             `<<-` <- base::`<<-`
  [12:36:06.256]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:06.256]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:06.256]                   3L)]
  [12:36:06.256]             }
  [12:36:06.256]             function(cond) {
  [12:36:06.256]                 is_error <- inherits(cond, "error")
  [12:36:06.256]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:06.256]                   NULL)
  [12:36:06.256]                 if (is_error) {
  [12:36:06.256]                   sessionInformation <- function() {
  [12:36:06.256]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:06.256]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:06.256]                       search = base::search(), system = base::Sys.info())
  [12:36:06.256]                   }
  [12:36:06.256]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:06.256]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:06.256]                     cond$call), session = sessionInformation(), 
  [12:36:06.256]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:06.256]                   signalCondition(cond)
  [12:36:06.256]                 }
  [12:36:06.256]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:06.256]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:06.256]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:06.256]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:06.256]                   if (FALSE && !signal) {
  [12:36:06.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:06.256]                     {
  [12:36:06.256]                       inherits <- base::inherits
  [12:36:06.256]                       invokeRestart <- base::invokeRestart
  [12:36:06.256]                       is.null <- base::is.null
  [12:36:06.256]                       muffled <- FALSE
  [12:36:06.256]                       if (inherits(cond, "message")) {
  [12:36:06.256]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:06.256]                         if (muffled) 
  [12:36:06.256]                           invokeRestart("muffleMessage")
  [12:36:06.256]                       }
  [12:36:06.256]                       else if (inherits(cond, "warning")) {
  [12:36:06.256]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:06.256]                         if (muffled) 
  [12:36:06.256]                           invokeRestart("muffleWarning")
  [12:36:06.256]                       }
  [12:36:06.256]                       else if (inherits(cond, "condition")) {
  [12:36:06.256]                         if (!is.null(pattern)) {
  [12:36:06.256]                           computeRestarts <- base::computeRestarts
  [12:36:06.256]                           grepl <- base::grepl
  [12:36:06.256]                           restarts <- computeRestarts(cond)
  [12:36:06.256]                           for (restart in restarts) {
  [12:36:06.256]                             name <- restart$name
  [12:36:06.256]                             if (is.null(name)) 
  [12:36:06.256]                               next
  [12:36:06.256]                             if (!grepl(pattern, name)) 
  [12:36:06.256]                               next
  [12:36:06.256]                             invokeRestart(restart)
  [12:36:06.256]                             muffled <- TRUE
  [12:36:06.256]                             break
  [12:36:06.256]                           }
  [12:36:06.256]                         }
  [12:36:06.256]                       }
  [12:36:06.256]                       invisible(muffled)
  [12:36:06.256]                     }
  [12:36:06.256]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:06.256]                   }
  [12:36:06.256]                 }
  [12:36:06.256]                 else {
  [12:36:06.256]                   if (TRUE) {
  [12:36:06.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:06.256]                     {
  [12:36:06.256]                       inherits <- base::inherits
  [12:36:06.256]                       invokeRestart <- base::invokeRestart
  [12:36:06.256]                       is.null <- base::is.null
  [12:36:06.256]                       muffled <- FALSE
  [12:36:06.256]                       if (inherits(cond, "message")) {
  [12:36:06.256]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:06.256]                         if (muffled) 
  [12:36:06.256]                           invokeRestart("muffleMessage")
  [12:36:06.256]                       }
  [12:36:06.256]                       else if (inherits(cond, "warning")) {
  [12:36:06.256]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:06.256]                         if (muffled) 
  [12:36:06.256]                           invokeRestart("muffleWarning")
  [12:36:06.256]                       }
  [12:36:06.256]                       else if (inherits(cond, "condition")) {
  [12:36:06.256]                         if (!is.null(pattern)) {
  [12:36:06.256]                           computeRestarts <- base::computeRestarts
  [12:36:06.256]                           grepl <- base::grepl
  [12:36:06.256]                           restarts <- computeRestarts(cond)
  [12:36:06.256]                           for (restart in restarts) {
  [12:36:06.256]                             name <- restart$name
  [12:36:06.256]                             if (is.null(name)) 
  [12:36:06.256]                               next
  [12:36:06.256]                             if (!grepl(pattern, name)) 
  [12:36:06.256]                               next
  [12:36:06.256]                             invokeRestart(restart)
  [12:36:06.256]                             muffled <- TRUE
  [12:36:06.256]                             break
  [12:36:06.256]                           }
  [12:36:06.256]                         }
  [12:36:06.256]                       }
  [12:36:06.256]                       invisible(muffled)
  [12:36:06.256]                     }
  [12:36:06.256]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:06.256]                   }
  [12:36:06.256]                 }
  [12:36:06.256]             }
  [12:36:06.256]         }))
  [12:36:06.256]     }, error = function(ex) {
  [12:36:06.256]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:06.256]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:06.256]                 ...future.rng), started = ...future.startTime, 
  [12:36:06.256]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:06.256]             version = "1.8"), class = "FutureResult")
  [12:36:06.256]     }, finally = {
  [12:36:06.256]         if (!identical(...future.workdir, getwd())) 
  [12:36:06.256]             setwd(...future.workdir)
  [12:36:06.256]         {
  [12:36:06.256]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:06.256]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:06.256]             }
  [12:36:06.256]             base::options(...future.oldOptions)
  [12:36:06.256]             if (.Platform$OS.type == "windows") {
  [12:36:06.256]                 old_names <- names(...future.oldEnvVars)
  [12:36:06.256]                 envs <- base::Sys.getenv()
  [12:36:06.256]                 names <- names(envs)
  [12:36:06.256]                 common <- intersect(names, old_names)
  [12:36:06.256]                 added <- setdiff(names, old_names)
  [12:36:06.256]                 removed <- setdiff(old_names, names)
  [12:36:06.256]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:06.256]                   envs[common]]
  [12:36:06.256]                 NAMES <- toupper(changed)
  [12:36:06.256]                 args <- list()
  [12:36:06.256]                 for (kk in seq_along(NAMES)) {
  [12:36:06.256]                   name <- changed[[kk]]
  [12:36:06.256]                   NAME <- NAMES[[kk]]
  [12:36:06.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:06.256]                     next
  [12:36:06.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:06.256]                 }
  [12:36:06.256]                 NAMES <- toupper(added)
  [12:36:06.256]                 for (kk in seq_along(NAMES)) {
  [12:36:06.256]                   name <- added[[kk]]
  [12:36:06.256]                   NAME <- NAMES[[kk]]
  [12:36:06.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:06.256]                     next
  [12:36:06.256]                   args[[name]] <- ""
  [12:36:06.256]                 }
  [12:36:06.256]                 NAMES <- toupper(removed)
  [12:36:06.256]                 for (kk in seq_along(NAMES)) {
  [12:36:06.256]                   name <- removed[[kk]]
  [12:36:06.256]                   NAME <- NAMES[[kk]]
  [12:36:06.256]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:06.256]                     next
  [12:36:06.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:06.256]                 }
  [12:36:06.256]                 if (length(args) > 0) 
  [12:36:06.256]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:06.256]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:06.256]             }
  [12:36:06.256]             else {
  [12:36:06.256]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:06.256]             }
  [12:36:06.256]             {
  [12:36:06.256]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:06.256]                   0L) {
  [12:36:06.256]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:06.256]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:06.256]                   base::options(opts)
  [12:36:06.256]                 }
  [12:36:06.256]                 {
  [12:36:06.256]                   NULL
  [12:36:06.256]                   options(future.plan = NULL)
  [12:36:06.256]                   if (is.na(NA_character_)) 
  [12:36:06.256]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:06.256]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:06.256]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:06.256]                     .init = FALSE)
  [12:36:06.256]                 }
  [12:36:06.256]             }
  [12:36:06.256]         }
  [12:36:06.256]     })
  [12:36:06.256]     if (TRUE) {
  [12:36:06.256]         base::sink(type = "output", split = FALSE)
  [12:36:06.256]         if (TRUE) {
  [12:36:06.256]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:06.256]         }
  [12:36:06.256]         else {
  [12:36:06.256]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:06.256]         }
  [12:36:06.256]         base::close(...future.stdout)
  [12:36:06.256]         ...future.stdout <- NULL
  [12:36:06.256]     }
  [12:36:06.256]     ...future.result$conditions <- ...future.conditions
  [12:36:06.256]     ...future.result$finished <- base::Sys.time()
  [12:36:06.256]     ...future.result
  [12:36:06.256] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/future.tests,mirai_cluster.R' failed.
Complete output:
  > if (requireNamespace("future.tests")) {
  +   mirai::daemons(0)  ## Reset any daemons running
  + 
  +   ## FIXME: The following is disabled on MS Windows, because it will
  +   ## result in a 'R CMD check' NOTE on "detritus in the temp directory" [1].
  +   ## This happens whenever we use mirai::daemons(..., dispatcher = TRUE).
  +   ## [1] https://github.com/shikokuchuo/mirai/discussions/105
  +   dispatcher <- (.Platform[["OS.type"]] != "windows")
  +   
  +   mirai::daemons(2, dispatcher = dispatcher)
  +   future.tests::check("future.mirai::mirai_cluster", timeout = 10.0, exit_value = FALSE)
  +   
  +   mirai::daemons(0)  ## Reset any daemons running
  +   gc()
  + }
  Loading required namespace: future.tests
  ── Settings ────────────────────────────────────────────────────────────────────
  - future.tests version      : 0.7.0
  - R_FUTURE_TESTS_ROOT       : 
  - Option 'future.tests.root': NULL
  - Default test set folder   : D:/RCompile/CRANpkg/lib/4.5/future.tests/test-db
  - Max number of workers     : 2
  - Timeout                   : 10 seconds
  
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: <Anonymous> ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/future.tests-mirai_multisession.R' failed.
Complete output:
  > if (requireNamespace("future.tests")) {
  +   mirai::daemons(0)  ## Reset any daemons running
  +   
  +   future.tests::check("future.mirai::mirai_multisession", timeout = 30.0, exit_value = FALSE)
  +   
  +   mirai::daemons(0)  ## Reset any daemons running
  +   gc()
  + }
  Loading required namespace: future.tests
  ── Settings ────────────────────────────────────────────────────────────────────
  - future.tests version      : 0.7.0
  - R_FUTURE_TESTS_ROOT       : 
  - Option 'future.tests.root': NULL
  - Default test set folder   : D:/RCompile/CRANpkg/lib/4.5/future.tests/test-db
  - Max number of workers     : 2
  - Timeout                   : 30 seconds
  
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: <Anonymous> ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/globals,formulas.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:12.381] plan(): Setting new future strategy stack:
  [12:36:12.382] List of future strategies:
  [12:36:12.382] 1. mirai_multisession:
  [12:36:12.382]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:12.382]    - tweaked: FALSE
  [12:36:12.382]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:12.399] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:12.400] < mirai [$data] >
  [12:36:12.407] getGlobalsAndPackages() ...
  [12:36:12.408] Not searching for globals
  [12:36:12.408] - globals: [0] <none>
  [12:36:12.408] getGlobalsAndPackages() ... DONE
  [12:36:12.409] getGlobalsAndPackages() ...
  [12:36:12.409] 
  [12:36:12.410] - globals: [0] <none>
  [12:36:12.410] getGlobalsAndPackages() ... DONE
  [12:36:12.822] Packages needed by the future expression (n = 0): <none>
  [12:36:12.823] Packages needed by future strategies (n = 0): <none>
  [12:36:12.824] {
  [12:36:12.824]     {
  [12:36:12.824]         {
  [12:36:12.824]             ...future.startTime <- base::Sys.time()
  [12:36:12.824]             {
  [12:36:12.824]                 {
  [12:36:12.824]                   {
  [12:36:12.824]                     base::local({
  [12:36:12.824]                       has_future <- base::requireNamespace("future", 
  [12:36:12.824]                         quietly = TRUE)
  [12:36:12.824]                       if (has_future) {
  [12:36:12.824]                         ns <- base::getNamespace("future")
  [12:36:12.824]                         version <- ns[[".package"]][["version"]]
  [12:36:12.824]                         if (is.null(version)) 
  [12:36:12.824]                           version <- utils::packageVersion("future")
  [12:36:12.824]                       }
  [12:36:12.824]                       else {
  [12:36:12.824]                         version <- NULL
  [12:36:12.824]                       }
  [12:36:12.824]                       if (!has_future || version < "1.8.0") {
  [12:36:12.824]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:12.824]                           "", base::R.version$version.string), 
  [12:36:12.824]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:12.824]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:12.824]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:12.824]                             "release", "version")], collapse = " "), 
  [12:36:12.824]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:12.824]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:12.824]                           info)
  [12:36:12.824]                         info <- base::paste(info, collapse = "; ")
  [12:36:12.824]                         if (!has_future) {
  [12:36:12.824]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:12.824]                             info)
  [12:36:12.824]                         }
  [12:36:12.824]                         else {
  [12:36:12.824]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:12.824]                             info, version)
  [12:36:12.824]                         }
  [12:36:12.824]                         base::stop(msg)
  [12:36:12.824]                       }
  [12:36:12.824]                     })
  [12:36:12.824]                   }
  [12:36:12.824]                   ...future.strategy.old <- future::plan("list")
  [12:36:12.824]                   options(future.plan = NULL)
  [12:36:12.824]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:12.824]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:12.824]                 }
  [12:36:12.824]                 ...future.workdir <- getwd()
  [12:36:12.824]             }
  [12:36:12.824]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:12.824]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:12.824]         }
  [12:36:12.824]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:12.824]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:12.824]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:12.824]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:12.824]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:12.824]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:12.824]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:12.824]             base::names(...future.oldOptions))
  [12:36:12.824]     }
  [12:36:12.824]     if (FALSE) {
  [12:36:12.824]     }
  [12:36:12.824]     else {
  [12:36:12.824]         if (TRUE) {
  [12:36:12.824]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:12.824]                 open = "w")
  [12:36:12.824]         }
  [12:36:12.824]         else {
  [12:36:12.824]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:12.824]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:12.824]         }
  [12:36:12.824]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:12.824]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:12.824]             base::sink(type = "output", split = FALSE)
  [12:36:12.824]             base::close(...future.stdout)
  [12:36:12.824]         }, add = TRUE)
  [12:36:12.824]     }
  [12:36:12.824]     ...future.frame <- base::sys.nframe()
  [12:36:12.824]     ...future.conditions <- base::list()
  [12:36:12.824]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:12.824]     if (FALSE) {
  [12:36:12.824]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:12.824]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:12.824]     }
  [12:36:12.824]     ...future.result <- base::tryCatch({
  [12:36:12.824]         base::withCallingHandlers({
  [12:36:12.824]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:12.824]             future::FutureResult(value = ...future.value$value, 
  [12:36:12.824]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:12.824]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:12.824]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:12.824]                     ...future.globalenv.names))
  [12:36:12.824]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:12.824]         }, condition = base::local({
  [12:36:12.824]             c <- base::c
  [12:36:12.824]             inherits <- base::inherits
  [12:36:12.824]             invokeRestart <- base::invokeRestart
  [12:36:12.824]             length <- base::length
  [12:36:12.824]             list <- base::list
  [12:36:12.824]             seq.int <- base::seq.int
  [12:36:12.824]             signalCondition <- base::signalCondition
  [12:36:12.824]             sys.calls <- base::sys.calls
  [12:36:12.824]             `[[` <- base::`[[`
  [12:36:12.824]             `+` <- base::`+`
  [12:36:12.824]             `<<-` <- base::`<<-`
  [12:36:12.824]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:12.824]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:12.824]                   3L)]
  [12:36:12.824]             }
  [12:36:12.824]             function(cond) {
  [12:36:12.824]                 is_error <- inherits(cond, "error")
  [12:36:12.824]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:12.824]                   NULL)
  [12:36:12.824]                 if (is_error) {
  [12:36:12.824]                   sessionInformation <- function() {
  [12:36:12.824]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:12.824]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:12.824]                       search = base::search(), system = base::Sys.info())
  [12:36:12.824]                   }
  [12:36:12.824]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:12.824]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:12.824]                     cond$call), session = sessionInformation(), 
  [12:36:12.824]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:12.824]                   signalCondition(cond)
  [12:36:12.824]                 }
  [12:36:12.824]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:12.824]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:12.824]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:12.824]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:12.824]                   if (FALSE && !signal) {
  [12:36:12.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:12.824]                     {
  [12:36:12.824]                       inherits <- base::inherits
  [12:36:12.824]                       invokeRestart <- base::invokeRestart
  [12:36:12.824]                       is.null <- base::is.null
  [12:36:12.824]                       muffled <- FALSE
  [12:36:12.824]                       if (inherits(cond, "message")) {
  [12:36:12.824]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:12.824]                         if (muffled) 
  [12:36:12.824]                           invokeRestart("muffleMessage")
  [12:36:12.824]                       }
  [12:36:12.824]                       else if (inherits(cond, "warning")) {
  [12:36:12.824]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:12.824]                         if (muffled) 
  [12:36:12.824]                           invokeRestart("muffleWarning")
  [12:36:12.824]                       }
  [12:36:12.824]                       else if (inherits(cond, "condition")) {
  [12:36:12.824]                         if (!is.null(pattern)) {
  [12:36:12.824]                           computeRestarts <- base::computeRestarts
  [12:36:12.824]                           grepl <- base::grepl
  [12:36:12.824]                           restarts <- computeRestarts(cond)
  [12:36:12.824]                           for (restart in restarts) {
  [12:36:12.824]                             name <- restart$name
  [12:36:12.824]                             if (is.null(name)) 
  [12:36:12.824]                               next
  [12:36:12.824]                             if (!grepl(pattern, name)) 
  [12:36:12.824]                               next
  [12:36:12.824]                             invokeRestart(restart)
  [12:36:12.824]                             muffled <- TRUE
  [12:36:12.824]                             break
  [12:36:12.824]                           }
  [12:36:12.824]                         }
  [12:36:12.824]                       }
  [12:36:12.824]                       invisible(muffled)
  [12:36:12.824]                     }
  [12:36:12.824]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:12.824]                   }
  [12:36:12.824]                 }
  [12:36:12.824]                 else {
  [12:36:12.824]                   if (TRUE) {
  [12:36:12.824]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:12.824]                     {
  [12:36:12.824]                       inherits <- base::inherits
  [12:36:12.824]                       invokeRestart <- base::invokeRestart
  [12:36:12.824]                       is.null <- base::is.null
  [12:36:12.824]                       muffled <- FALSE
  [12:36:12.824]                       if (inherits(cond, "message")) {
  [12:36:12.824]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:12.824]                         if (muffled) 
  [12:36:12.824]                           invokeRestart("muffleMessage")
  [12:36:12.824]                       }
  [12:36:12.824]                       else if (inherits(cond, "warning")) {
  [12:36:12.824]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:12.824]                         if (muffled) 
  [12:36:12.824]                           invokeRestart("muffleWarning")
  [12:36:12.824]                       }
  [12:36:12.824]                       else if (inherits(cond, "condition")) {
  [12:36:12.824]                         if (!is.null(pattern)) {
  [12:36:12.824]                           computeRestarts <- base::computeRestarts
  [12:36:12.824]                           grepl <- base::grepl
  [12:36:12.824]                           restarts <- computeRestarts(cond)
  [12:36:12.824]                           for (restart in restarts) {
  [12:36:12.824]                             name <- restart$name
  [12:36:12.824]                             if (is.null(name)) 
  [12:36:12.824]                               next
  [12:36:12.824]                             if (!grepl(pattern, name)) 
  [12:36:12.824]                               next
  [12:36:12.824]                             invokeRestart(restart)
  [12:36:12.824]                             muffled <- TRUE
  [12:36:12.824]                             break
  [12:36:12.824]                           }
  [12:36:12.824]                         }
  [12:36:12.824]                       }
  [12:36:12.824]                       invisible(muffled)
  [12:36:12.824]                     }
  [12:36:12.824]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:12.824]                   }
  [12:36:12.824]                 }
  [12:36:12.824]             }
  [12:36:12.824]         }))
  [12:36:12.824]     }, error = function(ex) {
  [12:36:12.824]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:12.824]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:12.824]                 ...future.rng), started = ...future.startTime, 
  [12:36:12.824]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:12.824]             version = "1.8"), class = "FutureResult")
  [12:36:12.824]     }, finally = {
  [12:36:12.824]         if (!identical(...future.workdir, getwd())) 
  [12:36:12.824]             setwd(...future.workdir)
  [12:36:12.824]         {
  [12:36:12.824]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:12.824]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:12.824]             }
  [12:36:12.824]             base::options(...future.oldOptions)
  [12:36:12.824]             if (.Platform$OS.type == "windows") {
  [12:36:12.824]                 old_names <- names(...future.oldEnvVars)
  [12:36:12.824]                 envs <- base::Sys.getenv()
  [12:36:12.824]                 names <- names(envs)
  [12:36:12.824]                 common <- intersect(names, old_names)
  [12:36:12.824]                 added <- setdiff(names, old_names)
  [12:36:12.824]                 removed <- setdiff(old_names, names)
  [12:36:12.824]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:12.824]                   envs[common]]
  [12:36:12.824]                 NAMES <- toupper(changed)
  [12:36:12.824]                 args <- list()
  [12:36:12.824]                 for (kk in seq_along(NAMES)) {
  [12:36:12.824]                   name <- changed[[kk]]
  [12:36:12.824]                   NAME <- NAMES[[kk]]
  [12:36:12.824]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:12.824]                     next
  [12:36:12.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:12.824]                 }
  [12:36:12.824]                 NAMES <- toupper(added)
  [12:36:12.824]                 for (kk in seq_along(NAMES)) {
  [12:36:12.824]                   name <- added[[kk]]
  [12:36:12.824]                   NAME <- NAMES[[kk]]
  [12:36:12.824]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:12.824]                     next
  [12:36:12.824]                   args[[name]] <- ""
  [12:36:12.824]                 }
  [12:36:12.824]                 NAMES <- toupper(removed)
  [12:36:12.824]                 for (kk in seq_along(NAMES)) {
  [12:36:12.824]                   name <- removed[[kk]]
  [12:36:12.824]                   NAME <- NAMES[[kk]]
  [12:36:12.824]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:12.824]                     next
  [12:36:12.824]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:12.824]                 }
  [12:36:12.824]                 if (length(args) > 0) 
  [12:36:12.824]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:12.824]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:12.824]             }
  [12:36:12.824]             else {
  [12:36:12.824]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:12.824]             }
  [12:36:12.824]             {
  [12:36:12.824]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:12.824]                   0L) {
  [12:36:12.824]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:12.824]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:12.824]                   base::options(opts)
  [12:36:12.824]                 }
  [12:36:12.824]                 {
  [12:36:12.824]                   NULL
  [12:36:12.824]                   options(future.plan = NULL)
  [12:36:12.824]                   if (is.na(NA_character_)) 
  [12:36:12.824]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:12.824]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:12.824]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:12.824]                     .init = FALSE)
  [12:36:12.824]                 }
  [12:36:12.824]             }
  [12:36:12.824]         }
  [12:36:12.824]     })
  [12:36:12.824]     if (TRUE) {
  [12:36:12.824]         base::sink(type = "output", split = FALSE)
  [12:36:12.824]         if (TRUE) {
  [12:36:12.824]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:12.824]         }
  [12:36:12.824]         else {
  [12:36:12.824]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:12.824]         }
  [12:36:12.824]         base::close(...future.stdout)
  [12:36:12.824]         ...future.stdout <- NULL
  [12:36:12.824]     }
  [12:36:12.824]     ...future.result$conditions <- ...future.conditions
  [12:36:12.824]     ...future.result$finished <- base::Sys.time()
  [12:36:12.824]     ...future.result
  [12:36:12.824] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/globals,manual.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:13.377] plan(): Setting new future strategy stack:
  [12:36:13.378] List of future strategies:
  [12:36:13.378] 1. mirai_multisession:
  [12:36:13.378]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:13.378]    - tweaked: FALSE
  [12:36:13.378]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:13.395] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:13.395] < mirai [$data] >
  [12:36:13.403] getGlobalsAndPackages() ...
  [12:36:13.403] Not searching for globals
  [12:36:13.404] - globals: [0] <none>
  [12:36:13.404] getGlobalsAndPackages() ... DONE
  [12:36:13.405] getGlobalsAndPackages() ...
  [12:36:13.405] 
  [12:36:13.405] - globals: [0] <none>
  [12:36:13.405] getGlobalsAndPackages() ... DONE
  [12:36:13.771] Packages needed by the future expression (n = 0): <none>
  [12:36:13.772] Packages needed by future strategies (n = 0): <none>
  [12:36:13.773] {
  [12:36:13.773]     {
  [12:36:13.773]         {
  [12:36:13.773]             ...future.startTime <- base::Sys.time()
  [12:36:13.773]             {
  [12:36:13.773]                 {
  [12:36:13.773]                   {
  [12:36:13.773]                     base::local({
  [12:36:13.773]                       has_future <- base::requireNamespace("future", 
  [12:36:13.773]                         quietly = TRUE)
  [12:36:13.773]                       if (has_future) {
  [12:36:13.773]                         ns <- base::getNamespace("future")
  [12:36:13.773]                         version <- ns[[".package"]][["version"]]
  [12:36:13.773]                         if (is.null(version)) 
  [12:36:13.773]                           version <- utils::packageVersion("future")
  [12:36:13.773]                       }
  [12:36:13.773]                       else {
  [12:36:13.773]                         version <- NULL
  [12:36:13.773]                       }
  [12:36:13.773]                       if (!has_future || version < "1.8.0") {
  [12:36:13.773]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:13.773]                           "", base::R.version$version.string), 
  [12:36:13.773]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:13.773]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:13.773]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:13.773]                             "release", "version")], collapse = " "), 
  [12:36:13.773]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:13.773]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:13.773]                           info)
  [12:36:13.773]                         info <- base::paste(info, collapse = "; ")
  [12:36:13.773]                         if (!has_future) {
  [12:36:13.773]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:13.773]                             info)
  [12:36:13.773]                         }
  [12:36:13.773]                         else {
  [12:36:13.773]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:13.773]                             info, version)
  [12:36:13.773]                         }
  [12:36:13.773]                         base::stop(msg)
  [12:36:13.773]                       }
  [12:36:13.773]                     })
  [12:36:13.773]                   }
  [12:36:13.773]                   ...future.strategy.old <- future::plan("list")
  [12:36:13.773]                   options(future.plan = NULL)
  [12:36:13.773]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:13.773]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:13.773]                 }
  [12:36:13.773]                 ...future.workdir <- getwd()
  [12:36:13.773]             }
  [12:36:13.773]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:13.773]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:13.773]         }
  [12:36:13.773]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:13.773]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:13.773]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:13.773]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:13.773]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:13.773]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:13.773]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:13.773]             base::names(...future.oldOptions))
  [12:36:13.773]     }
  [12:36:13.773]     if (FALSE) {
  [12:36:13.773]     }
  [12:36:13.773]     else {
  [12:36:13.773]         if (TRUE) {
  [12:36:13.773]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:13.773]                 open = "w")
  [12:36:13.773]         }
  [12:36:13.773]         else {
  [12:36:13.773]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:13.773]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:13.773]         }
  [12:36:13.773]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:13.773]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:13.773]             base::sink(type = "output", split = FALSE)
  [12:36:13.773]             base::close(...future.stdout)
  [12:36:13.773]         }, add = TRUE)
  [12:36:13.773]     }
  [12:36:13.773]     ...future.frame <- base::sys.nframe()
  [12:36:13.773]     ...future.conditions <- base::list()
  [12:36:13.773]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:13.773]     if (FALSE) {
  [12:36:13.773]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:13.773]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:13.773]     }
  [12:36:13.773]     ...future.result <- base::tryCatch({
  [12:36:13.773]         base::withCallingHandlers({
  [12:36:13.773]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:13.773]             future::FutureResult(value = ...future.value$value, 
  [12:36:13.773]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:13.773]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:13.773]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:13.773]                     ...future.globalenv.names))
  [12:36:13.773]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:13.773]         }, condition = base::local({
  [12:36:13.773]             c <- base::c
  [12:36:13.773]             inherits <- base::inherits
  [12:36:13.773]             invokeRestart <- base::invokeRestart
  [12:36:13.773]             length <- base::length
  [12:36:13.773]             list <- base::list
  [12:36:13.773]             seq.int <- base::seq.int
  [12:36:13.773]             signalCondition <- base::signalCondition
  [12:36:13.773]             sys.calls <- base::sys.calls
  [12:36:13.773]             `[[` <- base::`[[`
  [12:36:13.773]             `+` <- base::`+`
  [12:36:13.773]             `<<-` <- base::`<<-`
  [12:36:13.773]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:13.773]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:13.773]                   3L)]
  [12:36:13.773]             }
  [12:36:13.773]             function(cond) {
  [12:36:13.773]                 is_error <- inherits(cond, "error")
  [12:36:13.773]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:13.773]                   NULL)
  [12:36:13.773]                 if (is_error) {
  [12:36:13.773]                   sessionInformation <- function() {
  [12:36:13.773]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:13.773]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:13.773]                       search = base::search(), system = base::Sys.info())
  [12:36:13.773]                   }
  [12:36:13.773]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:13.773]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:13.773]                     cond$call), session = sessionInformation(), 
  [12:36:13.773]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:13.773]                   signalCondition(cond)
  [12:36:13.773]                 }
  [12:36:13.773]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:13.773]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:13.773]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:13.773]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:13.773]                   if (FALSE && !signal) {
  [12:36:13.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:13.773]                     {
  [12:36:13.773]                       inherits <- base::inherits
  [12:36:13.773]                       invokeRestart <- base::invokeRestart
  [12:36:13.773]                       is.null <- base::is.null
  [12:36:13.773]                       muffled <- FALSE
  [12:36:13.773]                       if (inherits(cond, "message")) {
  [12:36:13.773]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:13.773]                         if (muffled) 
  [12:36:13.773]                           invokeRestart("muffleMessage")
  [12:36:13.773]                       }
  [12:36:13.773]                       else if (inherits(cond, "warning")) {
  [12:36:13.773]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:13.773]                         if (muffled) 
  [12:36:13.773]                           invokeRestart("muffleWarning")
  [12:36:13.773]                       }
  [12:36:13.773]                       else if (inherits(cond, "condition")) {
  [12:36:13.773]                         if (!is.null(pattern)) {
  [12:36:13.773]                           computeRestarts <- base::computeRestarts
  [12:36:13.773]                           grepl <- base::grepl
  [12:36:13.773]                           restarts <- computeRestarts(cond)
  [12:36:13.773]                           for (restart in restarts) {
  [12:36:13.773]                             name <- restart$name
  [12:36:13.773]                             if (is.null(name)) 
  [12:36:13.773]                               next
  [12:36:13.773]                             if (!grepl(pattern, name)) 
  [12:36:13.773]                               next
  [12:36:13.773]                             invokeRestart(restart)
  [12:36:13.773]                             muffled <- TRUE
  [12:36:13.773]                             break
  [12:36:13.773]                           }
  [12:36:13.773]                         }
  [12:36:13.773]                       }
  [12:36:13.773]                       invisible(muffled)
  [12:36:13.773]                     }
  [12:36:13.773]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:13.773]                   }
  [12:36:13.773]                 }
  [12:36:13.773]                 else {
  [12:36:13.773]                   if (TRUE) {
  [12:36:13.773]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:13.773]                     {
  [12:36:13.773]                       inherits <- base::inherits
  [12:36:13.773]                       invokeRestart <- base::invokeRestart
  [12:36:13.773]                       is.null <- base::is.null
  [12:36:13.773]                       muffled <- FALSE
  [12:36:13.773]                       if (inherits(cond, "message")) {
  [12:36:13.773]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:13.773]                         if (muffled) 
  [12:36:13.773]                           invokeRestart("muffleMessage")
  [12:36:13.773]                       }
  [12:36:13.773]                       else if (inherits(cond, "warning")) {
  [12:36:13.773]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:13.773]                         if (muffled) 
  [12:36:13.773]                           invokeRestart("muffleWarning")
  [12:36:13.773]                       }
  [12:36:13.773]                       else if (inherits(cond, "condition")) {
  [12:36:13.773]                         if (!is.null(pattern)) {
  [12:36:13.773]                           computeRestarts <- base::computeRestarts
  [12:36:13.773]                           grepl <- base::grepl
  [12:36:13.773]                           restarts <- computeRestarts(cond)
  [12:36:13.773]                           for (restart in restarts) {
  [12:36:13.773]                             name <- restart$name
  [12:36:13.773]                             if (is.null(name)) 
  [12:36:13.773]                               next
  [12:36:13.773]                             if (!grepl(pattern, name)) 
  [12:36:13.773]                               next
  [12:36:13.773]                             invokeRestart(restart)
  [12:36:13.773]                             muffled <- TRUE
  [12:36:13.773]                             break
  [12:36:13.773]                           }
  [12:36:13.773]                         }
  [12:36:13.773]                       }
  [12:36:13.773]                       invisible(muffled)
  [12:36:13.773]                     }
  [12:36:13.773]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:13.773]                   }
  [12:36:13.773]                 }
  [12:36:13.773]             }
  [12:36:13.773]         }))
  [12:36:13.773]     }, error = function(ex) {
  [12:36:13.773]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:13.773]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:13.773]                 ...future.rng), started = ...future.startTime, 
  [12:36:13.773]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:13.773]             version = "1.8"), class = "FutureResult")
  [12:36:13.773]     }, finally = {
  [12:36:13.773]         if (!identical(...future.workdir, getwd())) 
  [12:36:13.773]             setwd(...future.workdir)
  [12:36:13.773]         {
  [12:36:13.773]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:13.773]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:13.773]             }
  [12:36:13.773]             base::options(...future.oldOptions)
  [12:36:13.773]             if (.Platform$OS.type == "windows") {
  [12:36:13.773]                 old_names <- names(...future.oldEnvVars)
  [12:36:13.773]                 envs <- base::Sys.getenv()
  [12:36:13.773]                 names <- names(envs)
  [12:36:13.773]                 common <- intersect(names, old_names)
  [12:36:13.773]                 added <- setdiff(names, old_names)
  [12:36:13.773]                 removed <- setdiff(old_names, names)
  [12:36:13.773]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:13.773]                   envs[common]]
  [12:36:13.773]                 NAMES <- toupper(changed)
  [12:36:13.773]                 args <- list()
  [12:36:13.773]                 for (kk in seq_along(NAMES)) {
  [12:36:13.773]                   name <- changed[[kk]]
  [12:36:13.773]                   NAME <- NAMES[[kk]]
  [12:36:13.773]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:13.773]                     next
  [12:36:13.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:13.773]                 }
  [12:36:13.773]                 NAMES <- toupper(added)
  [12:36:13.773]                 for (kk in seq_along(NAMES)) {
  [12:36:13.773]                   name <- added[[kk]]
  [12:36:13.773]                   NAME <- NAMES[[kk]]
  [12:36:13.773]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:13.773]                     next
  [12:36:13.773]                   args[[name]] <- ""
  [12:36:13.773]                 }
  [12:36:13.773]                 NAMES <- toupper(removed)
  [12:36:13.773]                 for (kk in seq_along(NAMES)) {
  [12:36:13.773]                   name <- removed[[kk]]
  [12:36:13.773]                   NAME <- NAMES[[kk]]
  [12:36:13.773]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:13.773]                     next
  [12:36:13.773]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:13.773]                 }
  [12:36:13.773]                 if (length(args) > 0) 
  [12:36:13.773]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:13.773]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:13.773]             }
  [12:36:13.773]             else {
  [12:36:13.773]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:13.773]             }
  [12:36:13.773]             {
  [12:36:13.773]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:13.773]                   0L) {
  [12:36:13.773]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:13.773]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:13.773]                   base::options(opts)
  [12:36:13.773]                 }
  [12:36:13.773]                 {
  [12:36:13.773]                   NULL
  [12:36:13.773]                   options(future.plan = NULL)
  [12:36:13.773]                   if (is.na(NA_character_)) 
  [12:36:13.773]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:13.773]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:13.773]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:13.773]                     .init = FALSE)
  [12:36:13.773]                 }
  [12:36:13.773]             }
  [12:36:13.773]         }
  [12:36:13.773]     })
  [12:36:13.773]     if (TRUE) {
  [12:36:13.773]         base::sink(type = "output", split = FALSE)
  [12:36:13.773]         if (TRUE) {
  [12:36:13.773]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:13.773]         }
  [12:36:13.773]         else {
  [12:36:13.773]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:13.773]         }
  [12:36:13.773]         base::close(...future.stdout)
  [12:36:13.773]         ...future.stdout <- NULL
  [12:36:13.773]     }
  [12:36:13.773]     ...future.result$conditions <- ...future.conditions
  [12:36:13.773]     ...future.result$finished <- base::Sys.time()
  [12:36:13.773]     ...future.result
  [12:36:13.773] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/globals,nested.R' failed.
Complete output:
  > ## This requires mirai (>= 0.13.2)
  > if (packageVersion("mirai") >= "0.13.2") {
  + library(future.mirai)
  + 
  + mirai::daemons(1, dispatcher = FALSE)
  + plan(mirai_cluster)
  + 
  + g <- function() 42
  + h <- function() g()
  + 
  + f <- future(h())
  + v <- value(f)
  + print(v)
  + stopifnot(v == h())
  + 
  + plan(sequential)
  + mirai::daemons(0)  ## Reset any daemons running
  + gc()
  + 
  + }
  Loading required package: future
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: plan ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/globals,subassignment.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:15.067] plan(): Setting new future strategy stack:
  [12:36:15.068] List of future strategies:
  [12:36:15.068] 1. mirai_multisession:
  [12:36:15.068]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:15.068]    - tweaked: FALSE
  [12:36:15.068]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:15.089] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:15.089] < mirai [$data] >
  [12:36:15.097] getGlobalsAndPackages() ...
  [12:36:15.097] Not searching for globals
  [12:36:15.098] - globals: [0] <none>
  [12:36:15.098] getGlobalsAndPackages() ... DONE
  [12:36:15.099] getGlobalsAndPackages() ...
  [12:36:15.099] 
  [12:36:15.100] - globals: [0] <none>
  [12:36:15.100] getGlobalsAndPackages() ... DONE
  [12:36:15.504] Packages needed by the future expression (n = 0): <none>
  [12:36:15.504] Packages needed by future strategies (n = 0): <none>
  [12:36:15.506] {
  [12:36:15.506]     {
  [12:36:15.506]         {
  [12:36:15.506]             ...future.startTime <- base::Sys.time()
  [12:36:15.506]             {
  [12:36:15.506]                 {
  [12:36:15.506]                   {
  [12:36:15.506]                     base::local({
  [12:36:15.506]                       has_future <- base::requireNamespace("future", 
  [12:36:15.506]                         quietly = TRUE)
  [12:36:15.506]                       if (has_future) {
  [12:36:15.506]                         ns <- base::getNamespace("future")
  [12:36:15.506]                         version <- ns[[".package"]][["version"]]
  [12:36:15.506]                         if (is.null(version)) 
  [12:36:15.506]                           version <- utils::packageVersion("future")
  [12:36:15.506]                       }
  [12:36:15.506]                       else {
  [12:36:15.506]                         version <- NULL
  [12:36:15.506]                       }
  [12:36:15.506]                       if (!has_future || version < "1.8.0") {
  [12:36:15.506]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:15.506]                           "", base::R.version$version.string), 
  [12:36:15.506]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:15.506]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:15.506]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:15.506]                             "release", "version")], collapse = " "), 
  [12:36:15.506]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:15.506]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:15.506]                           info)
  [12:36:15.506]                         info <- base::paste(info, collapse = "; ")
  [12:36:15.506]                         if (!has_future) {
  [12:36:15.506]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:15.506]                             info)
  [12:36:15.506]                         }
  [12:36:15.506]                         else {
  [12:36:15.506]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:15.506]                             info, version)
  [12:36:15.506]                         }
  [12:36:15.506]                         base::stop(msg)
  [12:36:15.506]                       }
  [12:36:15.506]                     })
  [12:36:15.506]                   }
  [12:36:15.506]                   ...future.strategy.old <- future::plan("list")
  [12:36:15.506]                   options(future.plan = NULL)
  [12:36:15.506]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:15.506]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:15.506]                 }
  [12:36:15.506]                 ...future.workdir <- getwd()
  [12:36:15.506]             }
  [12:36:15.506]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:15.506]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:15.506]         }
  [12:36:15.506]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:15.506]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:15.506]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:15.506]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:15.506]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:15.506]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:15.506]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:15.506]             base::names(...future.oldOptions))
  [12:36:15.506]     }
  [12:36:15.506]     if (FALSE) {
  [12:36:15.506]     }
  [12:36:15.506]     else {
  [12:36:15.506]         if (TRUE) {
  [12:36:15.506]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:15.506]                 open = "w")
  [12:36:15.506]         }
  [12:36:15.506]         else {
  [12:36:15.506]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:15.506]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:15.506]         }
  [12:36:15.506]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:15.506]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:15.506]             base::sink(type = "output", split = FALSE)
  [12:36:15.506]             base::close(...future.stdout)
  [12:36:15.506]         }, add = TRUE)
  [12:36:15.506]     }
  [12:36:15.506]     ...future.frame <- base::sys.nframe()
  [12:36:15.506]     ...future.conditions <- base::list()
  [12:36:15.506]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:15.506]     if (FALSE) {
  [12:36:15.506]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:15.506]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:15.506]     }
  [12:36:15.506]     ...future.result <- base::tryCatch({
  [12:36:15.506]         base::withCallingHandlers({
  [12:36:15.506]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:15.506]             future::FutureResult(value = ...future.value$value, 
  [12:36:15.506]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:15.506]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:15.506]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:15.506]                     ...future.globalenv.names))
  [12:36:15.506]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:15.506]         }, condition = base::local({
  [12:36:15.506]             c <- base::c
  [12:36:15.506]             inherits <- base::inherits
  [12:36:15.506]             invokeRestart <- base::invokeRestart
  [12:36:15.506]             length <- base::length
  [12:36:15.506]             list <- base::list
  [12:36:15.506]             seq.int <- base::seq.int
  [12:36:15.506]             signalCondition <- base::signalCondition
  [12:36:15.506]             sys.calls <- base::sys.calls
  [12:36:15.506]             `[[` <- base::`[[`
  [12:36:15.506]             `+` <- base::`+`
  [12:36:15.506]             `<<-` <- base::`<<-`
  [12:36:15.506]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:15.506]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:15.506]                   3L)]
  [12:36:15.506]             }
  [12:36:15.506]             function(cond) {
  [12:36:15.506]                 is_error <- inherits(cond, "error")
  [12:36:15.506]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:15.506]                   NULL)
  [12:36:15.506]                 if (is_error) {
  [12:36:15.506]                   sessionInformation <- function() {
  [12:36:15.506]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:15.506]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:15.506]                       search = base::search(), system = base::Sys.info())
  [12:36:15.506]                   }
  [12:36:15.506]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:15.506]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:15.506]                     cond$call), session = sessionInformation(), 
  [12:36:15.506]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:15.506]                   signalCondition(cond)
  [12:36:15.506]                 }
  [12:36:15.506]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:15.506]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:15.506]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:15.506]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:15.506]                   if (FALSE && !signal) {
  [12:36:15.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:15.506]                     {
  [12:36:15.506]                       inherits <- base::inherits
  [12:36:15.506]                       invokeRestart <- base::invokeRestart
  [12:36:15.506]                       is.null <- base::is.null
  [12:36:15.506]                       muffled <- FALSE
  [12:36:15.506]                       if (inherits(cond, "message")) {
  [12:36:15.506]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:15.506]                         if (muffled) 
  [12:36:15.506]                           invokeRestart("muffleMessage")
  [12:36:15.506]                       }
  [12:36:15.506]                       else if (inherits(cond, "warning")) {
  [12:36:15.506]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:15.506]                         if (muffled) 
  [12:36:15.506]                           invokeRestart("muffleWarning")
  [12:36:15.506]                       }
  [12:36:15.506]                       else if (inherits(cond, "condition")) {
  [12:36:15.506]                         if (!is.null(pattern)) {
  [12:36:15.506]                           computeRestarts <- base::computeRestarts
  [12:36:15.506]                           grepl <- base::grepl
  [12:36:15.506]                           restarts <- computeRestarts(cond)
  [12:36:15.506]                           for (restart in restarts) {
  [12:36:15.506]                             name <- restart$name
  [12:36:15.506]                             if (is.null(name)) 
  [12:36:15.506]                               next
  [12:36:15.506]                             if (!grepl(pattern, name)) 
  [12:36:15.506]                               next
  [12:36:15.506]                             invokeRestart(restart)
  [12:36:15.506]                             muffled <- TRUE
  [12:36:15.506]                             break
  [12:36:15.506]                           }
  [12:36:15.506]                         }
  [12:36:15.506]                       }
  [12:36:15.506]                       invisible(muffled)
  [12:36:15.506]                     }
  [12:36:15.506]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:15.506]                   }
  [12:36:15.506]                 }
  [12:36:15.506]                 else {
  [12:36:15.506]                   if (TRUE) {
  [12:36:15.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:15.506]                     {
  [12:36:15.506]                       inherits <- base::inherits
  [12:36:15.506]                       invokeRestart <- base::invokeRestart
  [12:36:15.506]                       is.null <- base::is.null
  [12:36:15.506]                       muffled <- FALSE
  [12:36:15.506]                       if (inherits(cond, "message")) {
  [12:36:15.506]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:15.506]                         if (muffled) 
  [12:36:15.506]                           invokeRestart("muffleMessage")
  [12:36:15.506]                       }
  [12:36:15.506]                       else if (inherits(cond, "warning")) {
  [12:36:15.506]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:15.506]                         if (muffled) 
  [12:36:15.506]                           invokeRestart("muffleWarning")
  [12:36:15.506]                       }
  [12:36:15.506]                       else if (inherits(cond, "condition")) {
  [12:36:15.506]                         if (!is.null(pattern)) {
  [12:36:15.506]                           computeRestarts <- base::computeRestarts
  [12:36:15.506]                           grepl <- base::grepl
  [12:36:15.506]                           restarts <- computeRestarts(cond)
  [12:36:15.506]                           for (restart in restarts) {
  [12:36:15.506]                             name <- restart$name
  [12:36:15.506]                             if (is.null(name)) 
  [12:36:15.506]                               next
  [12:36:15.506]                             if (!grepl(pattern, name)) 
  [12:36:15.506]                               next
  [12:36:15.506]                             invokeRestart(restart)
  [12:36:15.506]                             muffled <- TRUE
  [12:36:15.506]                             break
  [12:36:15.506]                           }
  [12:36:15.506]                         }
  [12:36:15.506]                       }
  [12:36:15.506]                       invisible(muffled)
  [12:36:15.506]                     }
  [12:36:15.506]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:15.506]                   }
  [12:36:15.506]                 }
  [12:36:15.506]             }
  [12:36:15.506]         }))
  [12:36:15.506]     }, error = function(ex) {
  [12:36:15.506]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:15.506]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:15.506]                 ...future.rng), started = ...future.startTime, 
  [12:36:15.506]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:15.506]             version = "1.8"), class = "FutureResult")
  [12:36:15.506]     }, finally = {
  [12:36:15.506]         if (!identical(...future.workdir, getwd())) 
  [12:36:15.506]             setwd(...future.workdir)
  [12:36:15.506]         {
  [12:36:15.506]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:15.506]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:15.506]             }
  [12:36:15.506]             base::options(...future.oldOptions)
  [12:36:15.506]             if (.Platform$OS.type == "windows") {
  [12:36:15.506]                 old_names <- names(...future.oldEnvVars)
  [12:36:15.506]                 envs <- base::Sys.getenv()
  [12:36:15.506]                 names <- names(envs)
  [12:36:15.506]                 common <- intersect(names, old_names)
  [12:36:15.506]                 added <- setdiff(names, old_names)
  [12:36:15.506]                 removed <- setdiff(old_names, names)
  [12:36:15.506]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:15.506]                   envs[common]]
  [12:36:15.506]                 NAMES <- toupper(changed)
  [12:36:15.506]                 args <- list()
  [12:36:15.506]                 for (kk in seq_along(NAMES)) {
  [12:36:15.506]                   name <- changed[[kk]]
  [12:36:15.506]                   NAME <- NAMES[[kk]]
  [12:36:15.506]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:15.506]                     next
  [12:36:15.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:15.506]                 }
  [12:36:15.506]                 NAMES <- toupper(added)
  [12:36:15.506]                 for (kk in seq_along(NAMES)) {
  [12:36:15.506]                   name <- added[[kk]]
  [12:36:15.506]                   NAME <- NAMES[[kk]]
  [12:36:15.506]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:15.506]                     next
  [12:36:15.506]                   args[[name]] <- ""
  [12:36:15.506]                 }
  [12:36:15.506]                 NAMES <- toupper(removed)
  [12:36:15.506]                 for (kk in seq_along(NAMES)) {
  [12:36:15.506]                   name <- removed[[kk]]
  [12:36:15.506]                   NAME <- NAMES[[kk]]
  [12:36:15.506]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:15.506]                     next
  [12:36:15.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:15.506]                 }
  [12:36:15.506]                 if (length(args) > 0) 
  [12:36:15.506]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:15.506]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:15.506]             }
  [12:36:15.506]             else {
  [12:36:15.506]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:15.506]             }
  [12:36:15.506]             {
  [12:36:15.506]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:15.506]                   0L) {
  [12:36:15.506]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:15.506]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:15.506]                   base::options(opts)
  [12:36:15.506]                 }
  [12:36:15.506]                 {
  [12:36:15.506]                   NULL
  [12:36:15.506]                   options(future.plan = NULL)
  [12:36:15.506]                   if (is.na(NA_character_)) 
  [12:36:15.506]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:15.506]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:15.506]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:15.506]                     .init = FALSE)
  [12:36:15.506]                 }
  [12:36:15.506]             }
  [12:36:15.506]         }
  [12:36:15.506]     })
  [12:36:15.506]     if (TRUE) {
  [12:36:15.506]         base::sink(type = "output", split = FALSE)
  [12:36:15.506]         if (TRUE) {
  [12:36:15.506]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:15.506]         }
  [12:36:15.506]         else {
  [12:36:15.506]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:15.506]         }
  [12:36:15.506]         base::close(...future.stdout)
  [12:36:15.506]         ...future.stdout <- NULL
  [12:36:15.506]     }
  [12:36:15.506]     ...future.result$conditions <- ...future.conditions
  [12:36:15.506]     ...future.result$finished <- base::Sys.time()
  [12:36:15.506]     ...future.result
  [12:36:15.506] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/globals,tricky.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:16.059] plan(): Setting new future strategy stack:
  [12:36:16.061] List of future strategies:
  [12:36:16.061] 1. mirai_multisession:
  [12:36:16.061]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:16.061]    - tweaked: FALSE
  [12:36:16.061]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:16.077] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:16.077] < mirai [$data] >
  [12:36:16.085] getGlobalsAndPackages() ...
  [12:36:16.085] Not searching for globals
  [12:36:16.086] - globals: [0] <none>
  [12:36:16.086] getGlobalsAndPackages() ... DONE
  [12:36:16.086] getGlobalsAndPackages() ...
  [12:36:16.087] 
  [12:36:16.087] - globals: [0] <none>
  [12:36:16.087] getGlobalsAndPackages() ... DONE
  [12:36:16.446] Packages needed by the future expression (n = 0): <none>
  [12:36:16.447] Packages needed by future strategies (n = 0): <none>
  [12:36:16.448] {
  [12:36:16.448]     {
  [12:36:16.448]         {
  [12:36:16.448]             ...future.startTime <- base::Sys.time()
  [12:36:16.448]             {
  [12:36:16.448]                 {
  [12:36:16.448]                   {
  [12:36:16.448]                     base::local({
  [12:36:16.448]                       has_future <- base::requireNamespace("future", 
  [12:36:16.448]                         quietly = TRUE)
  [12:36:16.448]                       if (has_future) {
  [12:36:16.448]                         ns <- base::getNamespace("future")
  [12:36:16.448]                         version <- ns[[".package"]][["version"]]
  [12:36:16.448]                         if (is.null(version)) 
  [12:36:16.448]                           version <- utils::packageVersion("future")
  [12:36:16.448]                       }
  [12:36:16.448]                       else {
  [12:36:16.448]                         version <- NULL
  [12:36:16.448]                       }
  [12:36:16.448]                       if (!has_future || version < "1.8.0") {
  [12:36:16.448]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:16.448]                           "", base::R.version$version.string), 
  [12:36:16.448]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:16.448]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:16.448]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:16.448]                             "release", "version")], collapse = " "), 
  [12:36:16.448]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:16.448]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:16.448]                           info)
  [12:36:16.448]                         info <- base::paste(info, collapse = "; ")
  [12:36:16.448]                         if (!has_future) {
  [12:36:16.448]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:16.448]                             info)
  [12:36:16.448]                         }
  [12:36:16.448]                         else {
  [12:36:16.448]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:16.448]                             info, version)
  [12:36:16.448]                         }
  [12:36:16.448]                         base::stop(msg)
  [12:36:16.448]                       }
  [12:36:16.448]                     })
  [12:36:16.448]                   }
  [12:36:16.448]                   ...future.strategy.old <- future::plan("list")
  [12:36:16.448]                   options(future.plan = NULL)
  [12:36:16.448]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:16.448]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:16.448]                 }
  [12:36:16.448]                 ...future.workdir <- getwd()
  [12:36:16.448]             }
  [12:36:16.448]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:16.448]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:16.448]         }
  [12:36:16.448]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:16.448]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:16.448]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:16.448]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:16.448]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:16.448]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:16.448]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:16.448]             base::names(...future.oldOptions))
  [12:36:16.448]     }
  [12:36:16.448]     if (FALSE) {
  [12:36:16.448]     }
  [12:36:16.448]     else {
  [12:36:16.448]         if (TRUE) {
  [12:36:16.448]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:16.448]                 open = "w")
  [12:36:16.448]         }
  [12:36:16.448]         else {
  [12:36:16.448]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:16.448]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:16.448]         }
  [12:36:16.448]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:16.448]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:16.448]             base::sink(type = "output", split = FALSE)
  [12:36:16.448]             base::close(...future.stdout)
  [12:36:16.448]         }, add = TRUE)
  [12:36:16.448]     }
  [12:36:16.448]     ...future.frame <- base::sys.nframe()
  [12:36:16.448]     ...future.conditions <- base::list()
  [12:36:16.448]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:16.448]     if (FALSE) {
  [12:36:16.448]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:16.448]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:16.448]     }
  [12:36:16.448]     ...future.result <- base::tryCatch({
  [12:36:16.448]         base::withCallingHandlers({
  [12:36:16.448]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:16.448]             future::FutureResult(value = ...future.value$value, 
  [12:36:16.448]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:16.448]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:16.448]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:16.448]                     ...future.globalenv.names))
  [12:36:16.448]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:16.448]         }, condition = base::local({
  [12:36:16.448]             c <- base::c
  [12:36:16.448]             inherits <- base::inherits
  [12:36:16.448]             invokeRestart <- base::invokeRestart
  [12:36:16.448]             length <- base::length
  [12:36:16.448]             list <- base::list
  [12:36:16.448]             seq.int <- base::seq.int
  [12:36:16.448]             signalCondition <- base::signalCondition
  [12:36:16.448]             sys.calls <- base::sys.calls
  [12:36:16.448]             `[[` <- base::`[[`
  [12:36:16.448]             `+` <- base::`+`
  [12:36:16.448]             `<<-` <- base::`<<-`
  [12:36:16.448]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:16.448]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:16.448]                   3L)]
  [12:36:16.448]             }
  [12:36:16.448]             function(cond) {
  [12:36:16.448]                 is_error <- inherits(cond, "error")
  [12:36:16.448]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:16.448]                   NULL)
  [12:36:16.448]                 if (is_error) {
  [12:36:16.448]                   sessionInformation <- function() {
  [12:36:16.448]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:16.448]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:16.448]                       search = base::search(), system = base::Sys.info())
  [12:36:16.448]                   }
  [12:36:16.448]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:16.448]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:16.448]                     cond$call), session = sessionInformation(), 
  [12:36:16.448]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:16.448]                   signalCondition(cond)
  [12:36:16.448]                 }
  [12:36:16.448]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:16.448]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:16.448]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:16.448]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:16.448]                   if (FALSE && !signal) {
  [12:36:16.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:16.448]                     {
  [12:36:16.448]                       inherits <- base::inherits
  [12:36:16.448]                       invokeRestart <- base::invokeRestart
  [12:36:16.448]                       is.null <- base::is.null
  [12:36:16.448]                       muffled <- FALSE
  [12:36:16.448]                       if (inherits(cond, "message")) {
  [12:36:16.448]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:16.448]                         if (muffled) 
  [12:36:16.448]                           invokeRestart("muffleMessage")
  [12:36:16.448]                       }
  [12:36:16.448]                       else if (inherits(cond, "warning")) {
  [12:36:16.448]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:16.448]                         if (muffled) 
  [12:36:16.448]                           invokeRestart("muffleWarning")
  [12:36:16.448]                       }
  [12:36:16.448]                       else if (inherits(cond, "condition")) {
  [12:36:16.448]                         if (!is.null(pattern)) {
  [12:36:16.448]                           computeRestarts <- base::computeRestarts
  [12:36:16.448]                           grepl <- base::grepl
  [12:36:16.448]                           restarts <- computeRestarts(cond)
  [12:36:16.448]                           for (restart in restarts) {
  [12:36:16.448]                             name <- restart$name
  [12:36:16.448]                             if (is.null(name)) 
  [12:36:16.448]                               next
  [12:36:16.448]                             if (!grepl(pattern, name)) 
  [12:36:16.448]                               next
  [12:36:16.448]                             invokeRestart(restart)
  [12:36:16.448]                             muffled <- TRUE
  [12:36:16.448]                             break
  [12:36:16.448]                           }
  [12:36:16.448]                         }
  [12:36:16.448]                       }
  [12:36:16.448]                       invisible(muffled)
  [12:36:16.448]                     }
  [12:36:16.448]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:16.448]                   }
  [12:36:16.448]                 }
  [12:36:16.448]                 else {
  [12:36:16.448]                   if (TRUE) {
  [12:36:16.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:16.448]                     {
  [12:36:16.448]                       inherits <- base::inherits
  [12:36:16.448]                       invokeRestart <- base::invokeRestart
  [12:36:16.448]                       is.null <- base::is.null
  [12:36:16.448]                       muffled <- FALSE
  [12:36:16.448]                       if (inherits(cond, "message")) {
  [12:36:16.448]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:16.448]                         if (muffled) 
  [12:36:16.448]                           invokeRestart("muffleMessage")
  [12:36:16.448]                       }
  [12:36:16.448]                       else if (inherits(cond, "warning")) {
  [12:36:16.448]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:16.448]                         if (muffled) 
  [12:36:16.448]                           invokeRestart("muffleWarning")
  [12:36:16.448]                       }
  [12:36:16.448]                       else if (inherits(cond, "condition")) {
  [12:36:16.448]                         if (!is.null(pattern)) {
  [12:36:16.448]                           computeRestarts <- base::computeRestarts
  [12:36:16.448]                           grepl <- base::grepl
  [12:36:16.448]                           restarts <- computeRestarts(cond)
  [12:36:16.448]                           for (restart in restarts) {
  [12:36:16.448]                             name <- restart$name
  [12:36:16.448]                             if (is.null(name)) 
  [12:36:16.448]                               next
  [12:36:16.448]                             if (!grepl(pattern, name)) 
  [12:36:16.448]                               next
  [12:36:16.448]                             invokeRestart(restart)
  [12:36:16.448]                             muffled <- TRUE
  [12:36:16.448]                             break
  [12:36:16.448]                           }
  [12:36:16.448]                         }
  [12:36:16.448]                       }
  [12:36:16.448]                       invisible(muffled)
  [12:36:16.448]                     }
  [12:36:16.448]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:16.448]                   }
  [12:36:16.448]                 }
  [12:36:16.448]             }
  [12:36:16.448]         }))
  [12:36:16.448]     }, error = function(ex) {
  [12:36:16.448]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:16.448]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:16.448]                 ...future.rng), started = ...future.startTime, 
  [12:36:16.448]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:16.448]             version = "1.8"), class = "FutureResult")
  [12:36:16.448]     }, finally = {
  [12:36:16.448]         if (!identical(...future.workdir, getwd())) 
  [12:36:16.448]             setwd(...future.workdir)
  [12:36:16.448]         {
  [12:36:16.448]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:16.448]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:16.448]             }
  [12:36:16.448]             base::options(...future.oldOptions)
  [12:36:16.448]             if (.Platform$OS.type == "windows") {
  [12:36:16.448]                 old_names <- names(...future.oldEnvVars)
  [12:36:16.448]                 envs <- base::Sys.getenv()
  [12:36:16.448]                 names <- names(envs)
  [12:36:16.448]                 common <- intersect(names, old_names)
  [12:36:16.448]                 added <- setdiff(names, old_names)
  [12:36:16.448]                 removed <- setdiff(old_names, names)
  [12:36:16.448]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:16.448]                   envs[common]]
  [12:36:16.448]                 NAMES <- toupper(changed)
  [12:36:16.448]                 args <- list()
  [12:36:16.448]                 for (kk in seq_along(NAMES)) {
  [12:36:16.448]                   name <- changed[[kk]]
  [12:36:16.448]                   NAME <- NAMES[[kk]]
  [12:36:16.448]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:16.448]                     next
  [12:36:16.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:16.448]                 }
  [12:36:16.448]                 NAMES <- toupper(added)
  [12:36:16.448]                 for (kk in seq_along(NAMES)) {
  [12:36:16.448]                   name <- added[[kk]]
  [12:36:16.448]                   NAME <- NAMES[[kk]]
  [12:36:16.448]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:16.448]                     next
  [12:36:16.448]                   args[[name]] <- ""
  [12:36:16.448]                 }
  [12:36:16.448]                 NAMES <- toupper(removed)
  [12:36:16.448]                 for (kk in seq_along(NAMES)) {
  [12:36:16.448]                   name <- removed[[kk]]
  [12:36:16.448]                   NAME <- NAMES[[kk]]
  [12:36:16.448]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:16.448]                     next
  [12:36:16.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:16.448]                 }
  [12:36:16.448]                 if (length(args) > 0) 
  [12:36:16.448]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:16.448]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:16.448]             }
  [12:36:16.448]             else {
  [12:36:16.448]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:16.448]             }
  [12:36:16.448]             {
  [12:36:16.448]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:16.448]                   0L) {
  [12:36:16.448]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:16.448]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:16.448]                   base::options(opts)
  [12:36:16.448]                 }
  [12:36:16.448]                 {
  [12:36:16.448]                   NULL
  [12:36:16.448]                   options(future.plan = NULL)
  [12:36:16.448]                   if (is.na(NA_character_)) 
  [12:36:16.448]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:16.448]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:16.448]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:16.448]                     .init = FALSE)
  [12:36:16.448]                 }
  [12:36:16.448]             }
  [12:36:16.448]         }
  [12:36:16.448]     })
  [12:36:16.448]     if (TRUE) {
  [12:36:16.448]         base::sink(type = "output", split = FALSE)
  [12:36:16.448]         if (TRUE) {
  [12:36:16.448]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:16.448]         }
  [12:36:16.448]         else {
  [12:36:16.448]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:16.448]         }
  [12:36:16.448]         base::close(...future.stdout)
  [12:36:16.448]         ...future.stdout <- NULL
  [12:36:16.448]     }
  [12:36:16.448]     ...future.result$conditions <- ...future.conditions
  [12:36:16.448]     ...future.result$finished <- base::Sys.time()
  [12:36:16.448]     ...future.result
  [12:36:16.448] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/mirai_cluster,worker-termination.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:16.963] plan(): Setting new future strategy stack:
  [12:36:16.965] List of future strategies:
  [12:36:16.965] 1. mirai_multisession:
  [12:36:16.965]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:16.965]    - tweaked: FALSE
  [12:36:16.965]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:16.986] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:16.987] < mirai [$data] >
  [12:36:16.995] getGlobalsAndPackages() ...
  [12:36:16.995] Not searching for globals
  [12:36:16.996] - globals: [0] <none>
  [12:36:16.996] getGlobalsAndPackages() ... DONE
  [12:36:16.997] getGlobalsAndPackages() ...
  [12:36:16.997] 
  [12:36:16.997] - globals: [0] <none>
  [12:36:16.997] getGlobalsAndPackages() ... DONE
  [12:36:17.440] Packages needed by the future expression (n = 0): <none>
  [12:36:17.440] Packages needed by future strategies (n = 0): <none>
  [12:36:17.443] {
  [12:36:17.443]     {
  [12:36:17.443]         {
  [12:36:17.443]             ...future.startTime <- base::Sys.time()
  [12:36:17.443]             {
  [12:36:17.443]                 {
  [12:36:17.443]                   {
  [12:36:17.443]                     base::local({
  [12:36:17.443]                       has_future <- base::requireNamespace("future", 
  [12:36:17.443]                         quietly = TRUE)
  [12:36:17.443]                       if (has_future) {
  [12:36:17.443]                         ns <- base::getNamespace("future")
  [12:36:17.443]                         version <- ns[[".package"]][["version"]]
  [12:36:17.443]                         if (is.null(version)) 
  [12:36:17.443]                           version <- utils::packageVersion("future")
  [12:36:17.443]                       }
  [12:36:17.443]                       else {
  [12:36:17.443]                         version <- NULL
  [12:36:17.443]                       }
  [12:36:17.443]                       if (!has_future || version < "1.8.0") {
  [12:36:17.443]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:17.443]                           "", base::R.version$version.string), 
  [12:36:17.443]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:17.443]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:17.443]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:17.443]                             "release", "version")], collapse = " "), 
  [12:36:17.443]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:17.443]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:17.443]                           info)
  [12:36:17.443]                         info <- base::paste(info, collapse = "; ")
  [12:36:17.443]                         if (!has_future) {
  [12:36:17.443]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:17.443]                             info)
  [12:36:17.443]                         }
  [12:36:17.443]                         else {
  [12:36:17.443]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:17.443]                             info, version)
  [12:36:17.443]                         }
  [12:36:17.443]                         base::stop(msg)
  [12:36:17.443]                       }
  [12:36:17.443]                     })
  [12:36:17.443]                   }
  [12:36:17.443]                   ...future.strategy.old <- future::plan("list")
  [12:36:17.443]                   options(future.plan = NULL)
  [12:36:17.443]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:17.443]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:17.443]                 }
  [12:36:17.443]                 ...future.workdir <- getwd()
  [12:36:17.443]             }
  [12:36:17.443]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:17.443]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:17.443]         }
  [12:36:17.443]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:17.443]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:17.443]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:17.443]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:17.443]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:17.443]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:17.443]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:17.443]             base::names(...future.oldOptions))
  [12:36:17.443]     }
  [12:36:17.443]     if (FALSE) {
  [12:36:17.443]     }
  [12:36:17.443]     else {
  [12:36:17.443]         if (TRUE) {
  [12:36:17.443]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:17.443]                 open = "w")
  [12:36:17.443]         }
  [12:36:17.443]         else {
  [12:36:17.443]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:17.443]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:17.443]         }
  [12:36:17.443]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:17.443]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:17.443]             base::sink(type = "output", split = FALSE)
  [12:36:17.443]             base::close(...future.stdout)
  [12:36:17.443]         }, add = TRUE)
  [12:36:17.443]     }
  [12:36:17.443]     ...future.frame <- base::sys.nframe()
  [12:36:17.443]     ...future.conditions <- base::list()
  [12:36:17.443]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:17.443]     if (FALSE) {
  [12:36:17.443]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:17.443]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:17.443]     }
  [12:36:17.443]     ...future.result <- base::tryCatch({
  [12:36:17.443]         base::withCallingHandlers({
  [12:36:17.443]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:17.443]             future::FutureResult(value = ...future.value$value, 
  [12:36:17.443]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:17.443]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:17.443]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:17.443]                     ...future.globalenv.names))
  [12:36:17.443]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:17.443]         }, condition = base::local({
  [12:36:17.443]             c <- base::c
  [12:36:17.443]             inherits <- base::inherits
  [12:36:17.443]             invokeRestart <- base::invokeRestart
  [12:36:17.443]             length <- base::length
  [12:36:17.443]             list <- base::list
  [12:36:17.443]             seq.int <- base::seq.int
  [12:36:17.443]             signalCondition <- base::signalCondition
  [12:36:17.443]             sys.calls <- base::sys.calls
  [12:36:17.443]             `[[` <- base::`[[`
  [12:36:17.443]             `+` <- base::`+`
  [12:36:17.443]             `<<-` <- base::`<<-`
  [12:36:17.443]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:17.443]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:17.443]                   3L)]
  [12:36:17.443]             }
  [12:36:17.443]             function(cond) {
  [12:36:17.443]                 is_error <- inherits(cond, "error")
  [12:36:17.443]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:17.443]                   NULL)
  [12:36:17.443]                 if (is_error) {
  [12:36:17.443]                   sessionInformation <- function() {
  [12:36:17.443]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:17.443]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:17.443]                       search = base::search(), system = base::Sys.info())
  [12:36:17.443]                   }
  [12:36:17.443]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:17.443]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:17.443]                     cond$call), session = sessionInformation(), 
  [12:36:17.443]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:17.443]                   signalCondition(cond)
  [12:36:17.443]                 }
  [12:36:17.443]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:17.443]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:17.443]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:17.443]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:17.443]                   if (FALSE && !signal) {
  [12:36:17.443]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:17.443]                     {
  [12:36:17.443]                       inherits <- base::inherits
  [12:36:17.443]                       invokeRestart <- base::invokeRestart
  [12:36:17.443]                       is.null <- base::is.null
  [12:36:17.443]                       muffled <- FALSE
  [12:36:17.443]                       if (inherits(cond, "message")) {
  [12:36:17.443]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:17.443]                         if (muffled) 
  [12:36:17.443]                           invokeRestart("muffleMessage")
  [12:36:17.443]                       }
  [12:36:17.443]                       else if (inherits(cond, "warning")) {
  [12:36:17.443]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:17.443]                         if (muffled) 
  [12:36:17.443]                           invokeRestart("muffleWarning")
  [12:36:17.443]                       }
  [12:36:17.443]                       else if (inherits(cond, "condition")) {
  [12:36:17.443]                         if (!is.null(pattern)) {
  [12:36:17.443]                           computeRestarts <- base::computeRestarts
  [12:36:17.443]                           grepl <- base::grepl
  [12:36:17.443]                           restarts <- computeRestarts(cond)
  [12:36:17.443]                           for (restart in restarts) {
  [12:36:17.443]                             name <- restart$name
  [12:36:17.443]                             if (is.null(name)) 
  [12:36:17.443]                               next
  [12:36:17.443]                             if (!grepl(pattern, name)) 
  [12:36:17.443]                               next
  [12:36:17.443]                             invokeRestart(restart)
  [12:36:17.443]                             muffled <- TRUE
  [12:36:17.443]                             break
  [12:36:17.443]                           }
  [12:36:17.443]                         }
  [12:36:17.443]                       }
  [12:36:17.443]                       invisible(muffled)
  [12:36:17.443]                     }
  [12:36:17.443]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:17.443]                   }
  [12:36:17.443]                 }
  [12:36:17.443]                 else {
  [12:36:17.443]                   if (TRUE) {
  [12:36:17.443]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:17.443]                     {
  [12:36:17.443]                       inherits <- base::inherits
  [12:36:17.443]                       invokeRestart <- base::invokeRestart
  [12:36:17.443]                       is.null <- base::is.null
  [12:36:17.443]                       muffled <- FALSE
  [12:36:17.443]                       if (inherits(cond, "message")) {
  [12:36:17.443]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:17.443]                         if (muffled) 
  [12:36:17.443]                           invokeRestart("muffleMessage")
  [12:36:17.443]                       }
  [12:36:17.443]                       else if (inherits(cond, "warning")) {
  [12:36:17.443]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:17.443]                         if (muffled) 
  [12:36:17.443]                           invokeRestart("muffleWarning")
  [12:36:17.443]                       }
  [12:36:17.443]                       else if (inherits(cond, "condition")) {
  [12:36:17.443]                         if (!is.null(pattern)) {
  [12:36:17.443]                           computeRestarts <- base::computeRestarts
  [12:36:17.443]                           grepl <- base::grepl
  [12:36:17.443]                           restarts <- computeRestarts(cond)
  [12:36:17.443]                           for (restart in restarts) {
  [12:36:17.443]                             name <- restart$name
  [12:36:17.443]                             if (is.null(name)) 
  [12:36:17.443]                               next
  [12:36:17.443]                             if (!grepl(pattern, name)) 
  [12:36:17.443]                               next
  [12:36:17.443]                             invokeRestart(restart)
  [12:36:17.443]                             muffled <- TRUE
  [12:36:17.443]                             break
  [12:36:17.443]                           }
  [12:36:17.443]                         }
  [12:36:17.443]                       }
  [12:36:17.443]                       invisible(muffled)
  [12:36:17.443]                     }
  [12:36:17.443]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:17.443]                   }
  [12:36:17.443]                 }
  [12:36:17.443]             }
  [12:36:17.443]         }))
  [12:36:17.443]     }, error = function(ex) {
  [12:36:17.443]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:17.443]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:17.443]                 ...future.rng), started = ...future.startTime, 
  [12:36:17.443]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:17.443]             version = "1.8"), class = "FutureResult")
  [12:36:17.443]     }, finally = {
  [12:36:17.443]         if (!identical(...future.workdir, getwd())) 
  [12:36:17.443]             setwd(...future.workdir)
  [12:36:17.443]         {
  [12:36:17.443]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:17.443]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:17.443]             }
  [12:36:17.443]             base::options(...future.oldOptions)
  [12:36:17.443]             if (.Platform$OS.type == "windows") {
  [12:36:17.443]                 old_names <- names(...future.oldEnvVars)
  [12:36:17.443]                 envs <- base::Sys.getenv()
  [12:36:17.443]                 names <- names(envs)
  [12:36:17.443]                 common <- intersect(names, old_names)
  [12:36:17.443]                 added <- setdiff(names, old_names)
  [12:36:17.443]                 removed <- setdiff(old_names, names)
  [12:36:17.443]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:17.443]                   envs[common]]
  [12:36:17.443]                 NAMES <- toupper(changed)
  [12:36:17.443]                 args <- list()
  [12:36:17.443]                 for (kk in seq_along(NAMES)) {
  [12:36:17.443]                   name <- changed[[kk]]
  [12:36:17.443]                   NAME <- NAMES[[kk]]
  [12:36:17.443]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:17.443]                     next
  [12:36:17.443]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:17.443]                 }
  [12:36:17.443]                 NAMES <- toupper(added)
  [12:36:17.443]                 for (kk in seq_along(NAMES)) {
  [12:36:17.443]                   name <- added[[kk]]
  [12:36:17.443]                   NAME <- NAMES[[kk]]
  [12:36:17.443]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:17.443]                     next
  [12:36:17.443]                   args[[name]] <- ""
  [12:36:17.443]                 }
  [12:36:17.443]                 NAMES <- toupper(removed)
  [12:36:17.443]                 for (kk in seq_along(NAMES)) {
  [12:36:17.443]                   name <- removed[[kk]]
  [12:36:17.443]                   NAME <- NAMES[[kk]]
  [12:36:17.443]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:17.443]                     next
  [12:36:17.443]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:17.443]                 }
  [12:36:17.443]                 if (length(args) > 0) 
  [12:36:17.443]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:17.443]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:17.443]             }
  [12:36:17.443]             else {
  [12:36:17.443]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:17.443]             }
  [12:36:17.443]             {
  [12:36:17.443]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:17.443]                   0L) {
  [12:36:17.443]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:17.443]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:17.443]                   base::options(opts)
  [12:36:17.443]                 }
  [12:36:17.443]                 {
  [12:36:17.443]                   NULL
  [12:36:17.443]                   options(future.plan = NULL)
  [12:36:17.443]                   if (is.na(NA_character_)) 
  [12:36:17.443]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:17.443]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:17.443]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:17.443]                     .init = FALSE)
  [12:36:17.443]                 }
  [12:36:17.443]             }
  [12:36:17.443]         }
  [12:36:17.443]     })
  [12:36:17.443]     if (TRUE) {
  [12:36:17.443]         base::sink(type = "output", split = FALSE)
  [12:36:17.443]         if (TRUE) {
  [12:36:17.443]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:17.443]         }
  [12:36:17.443]         else {
  [12:36:17.443]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:17.443]         }
  [12:36:17.443]         base::close(...future.stdout)
  [12:36:17.443]         ...future.stdout <- NULL
  [12:36:17.443]     }
  [12:36:17.443]     ...future.result$conditions <- ...future.conditions
  [12:36:17.443]     ...future.result$finished <- base::Sys.time()
  [12:36:17.443]     ...future.result
  [12:36:17.443] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/mirai_cluster.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:17.961] plan(): Setting new future strategy stack:
  [12:36:17.962] List of future strategies:
  [12:36:17.962] 1. mirai_multisession:
  [12:36:17.962]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:17.962]    - tweaked: FALSE
  [12:36:17.962]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:17.983] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:17.983] < mirai [$data] >
  [12:36:17.991] getGlobalsAndPackages() ...
  [12:36:17.991] Not searching for globals
  [12:36:17.992] - globals: [0] <none>
  [12:36:17.992] getGlobalsAndPackages() ... DONE
  [12:36:17.993] getGlobalsAndPackages() ...
  [12:36:17.993] 
  [12:36:17.993] - globals: [0] <none>
  [12:36:17.993] getGlobalsAndPackages() ... DONE
  [12:36:18.388] Packages needed by the future expression (n = 0): <none>
  [12:36:18.388] Packages needed by future strategies (n = 0): <none>
  [12:36:18.389] {
  [12:36:18.389]     {
  [12:36:18.389]         {
  [12:36:18.389]             ...future.startTime <- base::Sys.time()
  [12:36:18.389]             {
  [12:36:18.389]                 {
  [12:36:18.389]                   {
  [12:36:18.389]                     base::local({
  [12:36:18.389]                       has_future <- base::requireNamespace("future", 
  [12:36:18.389]                         quietly = TRUE)
  [12:36:18.389]                       if (has_future) {
  [12:36:18.389]                         ns <- base::getNamespace("future")
  [12:36:18.389]                         version <- ns[[".package"]][["version"]]
  [12:36:18.389]                         if (is.null(version)) 
  [12:36:18.389]                           version <- utils::packageVersion("future")
  [12:36:18.389]                       }
  [12:36:18.389]                       else {
  [12:36:18.389]                         version <- NULL
  [12:36:18.389]                       }
  [12:36:18.389]                       if (!has_future || version < "1.8.0") {
  [12:36:18.389]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:18.389]                           "", base::R.version$version.string), 
  [12:36:18.389]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:18.389]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:18.389]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:18.389]                             "release", "version")], collapse = " "), 
  [12:36:18.389]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:18.389]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:18.389]                           info)
  [12:36:18.389]                         info <- base::paste(info, collapse = "; ")
  [12:36:18.389]                         if (!has_future) {
  [12:36:18.389]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:18.389]                             info)
  [12:36:18.389]                         }
  [12:36:18.389]                         else {
  [12:36:18.389]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:18.389]                             info, version)
  [12:36:18.389]                         }
  [12:36:18.389]                         base::stop(msg)
  [12:36:18.389]                       }
  [12:36:18.389]                     })
  [12:36:18.389]                   }
  [12:36:18.389]                   ...future.strategy.old <- future::plan("list")
  [12:36:18.389]                   options(future.plan = NULL)
  [12:36:18.389]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:18.389]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:18.389]                 }
  [12:36:18.389]                 ...future.workdir <- getwd()
  [12:36:18.389]             }
  [12:36:18.389]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:18.389]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:18.389]         }
  [12:36:18.389]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:18.389]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:18.389]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:18.389]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:18.389]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:18.389]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:18.389]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:18.389]             base::names(...future.oldOptions))
  [12:36:18.389]     }
  [12:36:18.389]     if (FALSE) {
  [12:36:18.389]     }
  [12:36:18.389]     else {
  [12:36:18.389]         if (TRUE) {
  [12:36:18.389]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:18.389]                 open = "w")
  [12:36:18.389]         }
  [12:36:18.389]         else {
  [12:36:18.389]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:18.389]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:18.389]         }
  [12:36:18.389]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:18.389]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:18.389]             base::sink(type = "output", split = FALSE)
  [12:36:18.389]             base::close(...future.stdout)
  [12:36:18.389]         }, add = TRUE)
  [12:36:18.389]     }
  [12:36:18.389]     ...future.frame <- base::sys.nframe()
  [12:36:18.389]     ...future.conditions <- base::list()
  [12:36:18.389]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:18.389]     if (FALSE) {
  [12:36:18.389]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:18.389]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:18.389]     }
  [12:36:18.389]     ...future.result <- base::tryCatch({
  [12:36:18.389]         base::withCallingHandlers({
  [12:36:18.389]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:18.389]             future::FutureResult(value = ...future.value$value, 
  [12:36:18.389]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:18.389]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:18.389]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:18.389]                     ...future.globalenv.names))
  [12:36:18.389]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:18.389]         }, condition = base::local({
  [12:36:18.389]             c <- base::c
  [12:36:18.389]             inherits <- base::inherits
  [12:36:18.389]             invokeRestart <- base::invokeRestart
  [12:36:18.389]             length <- base::length
  [12:36:18.389]             list <- base::list
  [12:36:18.389]             seq.int <- base::seq.int
  [12:36:18.389]             signalCondition <- base::signalCondition
  [12:36:18.389]             sys.calls <- base::sys.calls
  [12:36:18.389]             `[[` <- base::`[[`
  [12:36:18.389]             `+` <- base::`+`
  [12:36:18.389]             `<<-` <- base::`<<-`
  [12:36:18.389]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:18.389]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:18.389]                   3L)]
  [12:36:18.389]             }
  [12:36:18.389]             function(cond) {
  [12:36:18.389]                 is_error <- inherits(cond, "error")
  [12:36:18.389]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:18.389]                   NULL)
  [12:36:18.389]                 if (is_error) {
  [12:36:18.389]                   sessionInformation <- function() {
  [12:36:18.389]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:18.389]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:18.389]                       search = base::search(), system = base::Sys.info())
  [12:36:18.389]                   }
  [12:36:18.389]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:18.389]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:18.389]                     cond$call), session = sessionInformation(), 
  [12:36:18.389]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:18.389]                   signalCondition(cond)
  [12:36:18.389]                 }
  [12:36:18.389]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:18.389]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:18.389]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:18.389]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:18.389]                   if (FALSE && !signal) {
  [12:36:18.389]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:18.389]                     {
  [12:36:18.389]                       inherits <- base::inherits
  [12:36:18.389]                       invokeRestart <- base::invokeRestart
  [12:36:18.389]                       is.null <- base::is.null
  [12:36:18.389]                       muffled <- FALSE
  [12:36:18.389]                       if (inherits(cond, "message")) {
  [12:36:18.389]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:18.389]                         if (muffled) 
  [12:36:18.389]                           invokeRestart("muffleMessage")
  [12:36:18.389]                       }
  [12:36:18.389]                       else if (inherits(cond, "warning")) {
  [12:36:18.389]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:18.389]                         if (muffled) 
  [12:36:18.389]                           invokeRestart("muffleWarning")
  [12:36:18.389]                       }
  [12:36:18.389]                       else if (inherits(cond, "condition")) {
  [12:36:18.389]                         if (!is.null(pattern)) {
  [12:36:18.389]                           computeRestarts <- base::computeRestarts
  [12:36:18.389]                           grepl <- base::grepl
  [12:36:18.389]                           restarts <- computeRestarts(cond)
  [12:36:18.389]                           for (restart in restarts) {
  [12:36:18.389]                             name <- restart$name
  [12:36:18.389]                             if (is.null(name)) 
  [12:36:18.389]                               next
  [12:36:18.389]                             if (!grepl(pattern, name)) 
  [12:36:18.389]                               next
  [12:36:18.389]                             invokeRestart(restart)
  [12:36:18.389]                             muffled <- TRUE
  [12:36:18.389]                             break
  [12:36:18.389]                           }
  [12:36:18.389]                         }
  [12:36:18.389]                       }
  [12:36:18.389]                       invisible(muffled)
  [12:36:18.389]                     }
  [12:36:18.389]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:18.389]                   }
  [12:36:18.389]                 }
  [12:36:18.389]                 else {
  [12:36:18.389]                   if (TRUE) {
  [12:36:18.389]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:18.389]                     {
  [12:36:18.389]                       inherits <- base::inherits
  [12:36:18.389]                       invokeRestart <- base::invokeRestart
  [12:36:18.389]                       is.null <- base::is.null
  [12:36:18.389]                       muffled <- FALSE
  [12:36:18.389]                       if (inherits(cond, "message")) {
  [12:36:18.389]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:18.389]                         if (muffled) 
  [12:36:18.389]                           invokeRestart("muffleMessage")
  [12:36:18.389]                       }
  [12:36:18.389]                       else if (inherits(cond, "warning")) {
  [12:36:18.389]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:18.389]                         if (muffled) 
  [12:36:18.389]                           invokeRestart("muffleWarning")
  [12:36:18.389]                       }
  [12:36:18.389]                       else if (inherits(cond, "condition")) {
  [12:36:18.389]                         if (!is.null(pattern)) {
  [12:36:18.389]                           computeRestarts <- base::computeRestarts
  [12:36:18.389]                           grepl <- base::grepl
  [12:36:18.389]                           restarts <- computeRestarts(cond)
  [12:36:18.389]                           for (restart in restarts) {
  [12:36:18.389]                             name <- restart$name
  [12:36:18.389]                             if (is.null(name)) 
  [12:36:18.389]                               next
  [12:36:18.389]                             if (!grepl(pattern, name)) 
  [12:36:18.389]                               next
  [12:36:18.389]                             invokeRestart(restart)
  [12:36:18.389]                             muffled <- TRUE
  [12:36:18.389]                             break
  [12:36:18.389]                           }
  [12:36:18.389]                         }
  [12:36:18.389]                       }
  [12:36:18.389]                       invisible(muffled)
  [12:36:18.389]                     }
  [12:36:18.389]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:18.389]                   }
  [12:36:18.389]                 }
  [12:36:18.389]             }
  [12:36:18.389]         }))
  [12:36:18.389]     }, error = function(ex) {
  [12:36:18.389]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:18.389]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:18.389]                 ...future.rng), started = ...future.startTime, 
  [12:36:18.389]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:18.389]             version = "1.8"), class = "FutureResult")
  [12:36:18.389]     }, finally = {
  [12:36:18.389]         if (!identical(...future.workdir, getwd())) 
  [12:36:18.389]             setwd(...future.workdir)
  [12:36:18.389]         {
  [12:36:18.389]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:18.389]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:18.389]             }
  [12:36:18.389]             base::options(...future.oldOptions)
  [12:36:18.389]             if (.Platform$OS.type == "windows") {
  [12:36:18.389]                 old_names <- names(...future.oldEnvVars)
  [12:36:18.389]                 envs <- base::Sys.getenv()
  [12:36:18.389]                 names <- names(envs)
  [12:36:18.389]                 common <- intersect(names, old_names)
  [12:36:18.389]                 added <- setdiff(names, old_names)
  [12:36:18.389]                 removed <- setdiff(old_names, names)
  [12:36:18.389]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:18.389]                   envs[common]]
  [12:36:18.389]                 NAMES <- toupper(changed)
  [12:36:18.389]                 args <- list()
  [12:36:18.389]                 for (kk in seq_along(NAMES)) {
  [12:36:18.389]                   name <- changed[[kk]]
  [12:36:18.389]                   NAME <- NAMES[[kk]]
  [12:36:18.389]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:18.389]                     next
  [12:36:18.389]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:18.389]                 }
  [12:36:18.389]                 NAMES <- toupper(added)
  [12:36:18.389]                 for (kk in seq_along(NAMES)) {
  [12:36:18.389]                   name <- added[[kk]]
  [12:36:18.389]                   NAME <- NAMES[[kk]]
  [12:36:18.389]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:18.389]                     next
  [12:36:18.389]                   args[[name]] <- ""
  [12:36:18.389]                 }
  [12:36:18.389]                 NAMES <- toupper(removed)
  [12:36:18.389]                 for (kk in seq_along(NAMES)) {
  [12:36:18.389]                   name <- removed[[kk]]
  [12:36:18.389]                   NAME <- NAMES[[kk]]
  [12:36:18.389]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:18.389]                     next
  [12:36:18.389]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:18.389]                 }
  [12:36:18.389]                 if (length(args) > 0) 
  [12:36:18.389]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:18.389]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:18.389]             }
  [12:36:18.389]             else {
  [12:36:18.389]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:18.389]             }
  [12:36:18.389]             {
  [12:36:18.389]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:18.389]                   0L) {
  [12:36:18.389]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:18.389]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:18.389]                   base::options(opts)
  [12:36:18.389]                 }
  [12:36:18.389]                 {
  [12:36:18.389]                   NULL
  [12:36:18.389]                   options(future.plan = NULL)
  [12:36:18.389]                   if (is.na(NA_character_)) 
  [12:36:18.389]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:18.389]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:18.389]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:18.389]                     .init = FALSE)
  [12:36:18.389]                 }
  [12:36:18.389]             }
  [12:36:18.389]         }
  [12:36:18.389]     })
  [12:36:18.389]     if (TRUE) {
  [12:36:18.389]         base::sink(type = "output", split = FALSE)
  [12:36:18.389]         if (TRUE) {
  [12:36:18.389]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:18.389]         }
  [12:36:18.389]         else {
  [12:36:18.389]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:18.389]         }
  [12:36:18.389]         base::close(...future.stdout)
  [12:36:18.389]         ...future.stdout <- NULL
  [12:36:18.389]     }
  [12:36:18.389]     ...future.result$conditions <- ...future.conditions
  [12:36:18.389]     ...future.result$finished <- base::Sys.time()
  [12:36:18.389]     ...future.result
  [12:36:18.389] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/nbrOfWorkers.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:18.956] plan(): Setting new future strategy stack:
  [12:36:18.957] List of future strategies:
  [12:36:18.957] 1. mirai_multisession:
  [12:36:18.957]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:18.957]    - tweaked: FALSE
  [12:36:18.957]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:18.980] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:18.981] < mirai [$data] >
  [12:36:18.987] getGlobalsAndPackages() ...
  [12:36:18.988] Not searching for globals
  [12:36:18.988] - globals: [0] <none>
  [12:36:18.989] getGlobalsAndPackages() ... DONE
  [12:36:18.989] getGlobalsAndPackages() ...
  [12:36:18.990] 
  [12:36:18.990] - globals: [0] <none>
  [12:36:18.990] getGlobalsAndPackages() ... DONE
  [12:36:19.368] Packages needed by the future expression (n = 0): <none>
  [12:36:19.369] Packages needed by future strategies (n = 0): <none>
  [12:36:19.370] {
  [12:36:19.370]     {
  [12:36:19.370]         {
  [12:36:19.370]             ...future.startTime <- base::Sys.time()
  [12:36:19.370]             {
  [12:36:19.370]                 {
  [12:36:19.370]                   {
  [12:36:19.370]                     base::local({
  [12:36:19.370]                       has_future <- base::requireNamespace("future", 
  [12:36:19.370]                         quietly = TRUE)
  [12:36:19.370]                       if (has_future) {
  [12:36:19.370]                         ns <- base::getNamespace("future")
  [12:36:19.370]                         version <- ns[[".package"]][["version"]]
  [12:36:19.370]                         if (is.null(version)) 
  [12:36:19.370]                           version <- utils::packageVersion("future")
  [12:36:19.370]                       }
  [12:36:19.370]                       else {
  [12:36:19.370]                         version <- NULL
  [12:36:19.370]                       }
  [12:36:19.370]                       if (!has_future || version < "1.8.0") {
  [12:36:19.370]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:19.370]                           "", base::R.version$version.string), 
  [12:36:19.370]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:19.370]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:19.370]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:19.370]                             "release", "version")], collapse = " "), 
  [12:36:19.370]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:19.370]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:19.370]                           info)
  [12:36:19.370]                         info <- base::paste(info, collapse = "; ")
  [12:36:19.370]                         if (!has_future) {
  [12:36:19.370]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:19.370]                             info)
  [12:36:19.370]                         }
  [12:36:19.370]                         else {
  [12:36:19.370]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:19.370]                             info, version)
  [12:36:19.370]                         }
  [12:36:19.370]                         base::stop(msg)
  [12:36:19.370]                       }
  [12:36:19.370]                     })
  [12:36:19.370]                   }
  [12:36:19.370]                   ...future.strategy.old <- future::plan("list")
  [12:36:19.370]                   options(future.plan = NULL)
  [12:36:19.370]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:19.370]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:19.370]                 }
  [12:36:19.370]                 ...future.workdir <- getwd()
  [12:36:19.370]             }
  [12:36:19.370]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:19.370]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:19.370]         }
  [12:36:19.370]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:19.370]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:19.370]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:19.370]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:19.370]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:19.370]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:19.370]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:19.370]             base::names(...future.oldOptions))
  [12:36:19.370]     }
  [12:36:19.370]     if (FALSE) {
  [12:36:19.370]     }
  [12:36:19.370]     else {
  [12:36:19.370]         if (TRUE) {
  [12:36:19.370]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:19.370]                 open = "w")
  [12:36:19.370]         }
  [12:36:19.370]         else {
  [12:36:19.370]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:19.370]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:19.370]         }
  [12:36:19.370]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:19.370]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:19.370]             base::sink(type = "output", split = FALSE)
  [12:36:19.370]             base::close(...future.stdout)
  [12:36:19.370]         }, add = TRUE)
  [12:36:19.370]     }
  [12:36:19.370]     ...future.frame <- base::sys.nframe()
  [12:36:19.370]     ...future.conditions <- base::list()
  [12:36:19.370]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:19.370]     if (FALSE) {
  [12:36:19.370]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:19.370]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:19.370]     }
  [12:36:19.370]     ...future.result <- base::tryCatch({
  [12:36:19.370]         base::withCallingHandlers({
  [12:36:19.370]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:19.370]             future::FutureResult(value = ...future.value$value, 
  [12:36:19.370]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:19.370]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:19.370]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:19.370]                     ...future.globalenv.names))
  [12:36:19.370]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:19.370]         }, condition = base::local({
  [12:36:19.370]             c <- base::c
  [12:36:19.370]             inherits <- base::inherits
  [12:36:19.370]             invokeRestart <- base::invokeRestart
  [12:36:19.370]             length <- base::length
  [12:36:19.370]             list <- base::list
  [12:36:19.370]             seq.int <- base::seq.int
  [12:36:19.370]             signalCondition <- base::signalCondition
  [12:36:19.370]             sys.calls <- base::sys.calls
  [12:36:19.370]             `[[` <- base::`[[`
  [12:36:19.370]             `+` <- base::`+`
  [12:36:19.370]             `<<-` <- base::`<<-`
  [12:36:19.370]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:19.370]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:19.370]                   3L)]
  [12:36:19.370]             }
  [12:36:19.370]             function(cond) {
  [12:36:19.370]                 is_error <- inherits(cond, "error")
  [12:36:19.370]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:19.370]                   NULL)
  [12:36:19.370]                 if (is_error) {
  [12:36:19.370]                   sessionInformation <- function() {
  [12:36:19.370]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:19.370]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:19.370]                       search = base::search(), system = base::Sys.info())
  [12:36:19.370]                   }
  [12:36:19.370]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:19.370]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:19.370]                     cond$call), session = sessionInformation(), 
  [12:36:19.370]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:19.370]                   signalCondition(cond)
  [12:36:19.370]                 }
  [12:36:19.370]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:19.370]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:19.370]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:19.370]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:19.370]                   if (FALSE && !signal) {
  [12:36:19.370]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:19.370]                     {
  [12:36:19.370]                       inherits <- base::inherits
  [12:36:19.370]                       invokeRestart <- base::invokeRestart
  [12:36:19.370]                       is.null <- base::is.null
  [12:36:19.370]                       muffled <- FALSE
  [12:36:19.370]                       if (inherits(cond, "message")) {
  [12:36:19.370]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:19.370]                         if (muffled) 
  [12:36:19.370]                           invokeRestart("muffleMessage")
  [12:36:19.370]                       }
  [12:36:19.370]                       else if (inherits(cond, "warning")) {
  [12:36:19.370]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:19.370]                         if (muffled) 
  [12:36:19.370]                           invokeRestart("muffleWarning")
  [12:36:19.370]                       }
  [12:36:19.370]                       else if (inherits(cond, "condition")) {
  [12:36:19.370]                         if (!is.null(pattern)) {
  [12:36:19.370]                           computeRestarts <- base::computeRestarts
  [12:36:19.370]                           grepl <- base::grepl
  [12:36:19.370]                           restarts <- computeRestarts(cond)
  [12:36:19.370]                           for (restart in restarts) {
  [12:36:19.370]                             name <- restart$name
  [12:36:19.370]                             if (is.null(name)) 
  [12:36:19.370]                               next
  [12:36:19.370]                             if (!grepl(pattern, name)) 
  [12:36:19.370]                               next
  [12:36:19.370]                             invokeRestart(restart)
  [12:36:19.370]                             muffled <- TRUE
  [12:36:19.370]                             break
  [12:36:19.370]                           }
  [12:36:19.370]                         }
  [12:36:19.370]                       }
  [12:36:19.370]                       invisible(muffled)
  [12:36:19.370]                     }
  [12:36:19.370]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:19.370]                   }
  [12:36:19.370]                 }
  [12:36:19.370]                 else {
  [12:36:19.370]                   if (TRUE) {
  [12:36:19.370]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:19.370]                     {
  [12:36:19.370]                       inherits <- base::inherits
  [12:36:19.370]                       invokeRestart <- base::invokeRestart
  [12:36:19.370]                       is.null <- base::is.null
  [12:36:19.370]                       muffled <- FALSE
  [12:36:19.370]                       if (inherits(cond, "message")) {
  [12:36:19.370]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:19.370]                         if (muffled) 
  [12:36:19.370]                           invokeRestart("muffleMessage")
  [12:36:19.370]                       }
  [12:36:19.370]                       else if (inherits(cond, "warning")) {
  [12:36:19.370]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:19.370]                         if (muffled) 
  [12:36:19.370]                           invokeRestart("muffleWarning")
  [12:36:19.370]                       }
  [12:36:19.370]                       else if (inherits(cond, "condition")) {
  [12:36:19.370]                         if (!is.null(pattern)) {
  [12:36:19.370]                           computeRestarts <- base::computeRestarts
  [12:36:19.370]                           grepl <- base::grepl
  [12:36:19.370]                           restarts <- computeRestarts(cond)
  [12:36:19.370]                           for (restart in restarts) {
  [12:36:19.370]                             name <- restart$name
  [12:36:19.370]                             if (is.null(name)) 
  [12:36:19.370]                               next
  [12:36:19.370]                             if (!grepl(pattern, name)) 
  [12:36:19.370]                               next
  [12:36:19.370]                             invokeRestart(restart)
  [12:36:19.370]                             muffled <- TRUE
  [12:36:19.370]                             break
  [12:36:19.370]                           }
  [12:36:19.370]                         }
  [12:36:19.370]                       }
  [12:36:19.370]                       invisible(muffled)
  [12:36:19.370]                     }
  [12:36:19.370]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:19.370]                   }
  [12:36:19.370]                 }
  [12:36:19.370]             }
  [12:36:19.370]         }))
  [12:36:19.370]     }, error = function(ex) {
  [12:36:19.370]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:19.370]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:19.370]                 ...future.rng), started = ...future.startTime, 
  [12:36:19.370]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:19.370]             version = "1.8"), class = "FutureResult")
  [12:36:19.370]     }, finally = {
  [12:36:19.370]         if (!identical(...future.workdir, getwd())) 
  [12:36:19.370]             setwd(...future.workdir)
  [12:36:19.370]         {
  [12:36:19.370]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:19.370]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:19.370]             }
  [12:36:19.370]             base::options(...future.oldOptions)
  [12:36:19.370]             if (.Platform$OS.type == "windows") {
  [12:36:19.370]                 old_names <- names(...future.oldEnvVars)
  [12:36:19.370]                 envs <- base::Sys.getenv()
  [12:36:19.370]                 names <- names(envs)
  [12:36:19.370]                 common <- intersect(names, old_names)
  [12:36:19.370]                 added <- setdiff(names, old_names)
  [12:36:19.370]                 removed <- setdiff(old_names, names)
  [12:36:19.370]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:19.370]                   envs[common]]
  [12:36:19.370]                 NAMES <- toupper(changed)
  [12:36:19.370]                 args <- list()
  [12:36:19.370]                 for (kk in seq_along(NAMES)) {
  [12:36:19.370]                   name <- changed[[kk]]
  [12:36:19.370]                   NAME <- NAMES[[kk]]
  [12:36:19.370]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:19.370]                     next
  [12:36:19.370]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:19.370]                 }
  [12:36:19.370]                 NAMES <- toupper(added)
  [12:36:19.370]                 for (kk in seq_along(NAMES)) {
  [12:36:19.370]                   name <- added[[kk]]
  [12:36:19.370]                   NAME <- NAMES[[kk]]
  [12:36:19.370]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:19.370]                     next
  [12:36:19.370]                   args[[name]] <- ""
  [12:36:19.370]                 }
  [12:36:19.370]                 NAMES <- toupper(removed)
  [12:36:19.370]                 for (kk in seq_along(NAMES)) {
  [12:36:19.370]                   name <- removed[[kk]]
  [12:36:19.370]                   NAME <- NAMES[[kk]]
  [12:36:19.370]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:19.370]                     next
  [12:36:19.370]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:19.370]                 }
  [12:36:19.370]                 if (length(args) > 0) 
  [12:36:19.370]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:19.370]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:19.370]             }
  [12:36:19.370]             else {
  [12:36:19.370]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:19.370]             }
  [12:36:19.370]             {
  [12:36:19.370]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:19.370]                   0L) {
  [12:36:19.370]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:19.370]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:19.370]                   base::options(opts)
  [12:36:19.370]                 }
  [12:36:19.370]                 {
  [12:36:19.370]                   NULL
  [12:36:19.370]                   options(future.plan = NULL)
  [12:36:19.370]                   if (is.na(NA_character_)) 
  [12:36:19.370]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:19.370]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:19.370]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:19.370]                     .init = FALSE)
  [12:36:19.370]                 }
  [12:36:19.370]             }
  [12:36:19.370]         }
  [12:36:19.370]     })
  [12:36:19.370]     if (TRUE) {
  [12:36:19.370]         base::sink(type = "output", split = FALSE)
  [12:36:19.370]         if (TRUE) {
  [12:36:19.370]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:19.370]         }
  [12:36:19.370]         else {
  [12:36:19.370]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:19.370]         }
  [12:36:19.370]         base::close(...future.stdout)
  [12:36:19.370]         ...future.stdout <- NULL
  [12:36:19.370]     }
  [12:36:19.370]     ...future.result$conditions <- ...future.conditions
  [12:36:19.370]     ...future.result$finished <- base::Sys.time()
  [12:36:19.370]     ...future.result
  [12:36:19.370] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/plan.R' failed.
Complete output:
  > source("incl/start,load-only.R")
  [12:36:19.774] Detected 'R CMD check':
   - adjusting defaults to be a good citizen
  [12:36:19.776] Set package option 'parallelly.availableCores.methods'
  [12:36:19.777] Environment variable 'R_PARALLELLY_AVAILABLECORES_METHODS' not set
  [12:36:19.777] Set package option 'parallelly.availableCores.fallback'
  [12:36:19.777] Environment variable 'R_PARALLELLY_AVAILABLECORES_FALLBACK' not set
  [12:36:19.777] Set package option 'parallelly.availableCores.min'
  [12:36:19.778] Environment variable 'R_PARALLELLY_AVAILABLECORES_MIN' not set
  [12:36:19.778] Set package option 'parallelly.availableCores.system'
  [12:36:19.778] Environment variable 'R_PARALLELLY_AVAILABLECORES_SYSTEM' not set
  [12:36:19.778] Set package option 'parallelly.availableCores.logical'
  [12:36:19.779] Environment variable 'R_PARALLELLY_AVAILABLECORES_LOGICAL' not set
  [12:36:19.779] Set package option 'parallelly.availableCores.omit'
  [12:36:19.779] Environment variable 'R_PARALLELLY_AVAILABLECORES_OMIT' not set
  [12:36:19.780] Set package option 'parallelly.availableWorkers.methods'
  [12:36:19.780] Environment variable 'R_PARALLELLY_AVAILABLEWORKERS_METHODS' not set
  [12:36:19.780] Set package option 'parallelly.maxWorkers.localhost'
  [12:36:19.780] Environment variable 'R_PARALLELLY_MAXWORKERS_LOCALHOST' not set
  [12:36:19.781] Set package option 'parallelly.maxWorkers.localhost.ignore'
  [12:36:19.781] Environment variable 'R_PARALLELLY_MAXWORKERS_LOCALHOST_IGNORE' not set
  [12:36:19.781] Set package option 'parallelly.fork.enable'
  [12:36:19.781] Environment variable 'R_PARALLELLY_FORK_ENABLE' not set
  [12:36:19.782] Set package option 'parallelly.supportsMulticore.disableOn'
  [12:36:19.782] Environment variable 'R_PARALLELLY_SUPPORTSMULTICORE_DISABLEON' not set
  [12:36:19.782] Set package option 'parallelly.supportsMulticore.unstable'
  [12:36:19.782] Environment variable 'R_PARALLELLY_SUPPORTSMULTICORE_UNSTABLE' not set
  [12:36:19.783] Set package option 'parallelly.makeNodePSOCK.setup_strategy'
  [12:36:19.783] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_SETUP_STRATEGY' not set
  [12:36:19.783] Set package option 'parallelly.makeNodePSOCK.validate'
  [12:36:19.783] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_VALIDATE' not set
  [12:36:19.784] Set package option 'parallelly.makeNodePSOCK.connectTimeout'
  [12:36:19.784] R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT='120'
  [12:36:19.784] Coercing from character to numeric: '120'
  [12:36:19.784] => options("parallelly.makeNodePSOCK.connectTimeout" = '120') [n=1, mode=double]
  [12:36:19.785] Set package option 'parallelly.makeNodePSOCK.timeout'
  [12:36:19.785] R_PARALLELLY_MAKENODEPSOCK_TIMEOUT='120'
  [12:36:19.785] Coercing from character to numeric: '120'
  [12:36:19.786] => options("parallelly.makeNodePSOCK.timeout" = '120') [n=1, mode=double]
  [12:36:19.786] Set package option 'parallelly.makeNodePSOCK.useXDR'
  [12:36:19.787] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_USEXDR' not set
  [12:36:19.787] Set package option 'parallelly.makeNodePSOCK.socketOptions'
  [12:36:19.787] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_SOCKETOPTIONS' not set
  [12:36:19.787] Set package option 'parallelly.makeNodePSOCK.rshcmd'
  [12:36:19.788] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_RSHCMD' not set
  [12:36:19.788] Set package option 'parallelly.makeNodePSOCK.rshopts'
  [12:36:19.788] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_RSHOPTS' not set
  [12:36:19.789] Set package option 'parallelly.makeNodePSOCK.tries'
  [12:36:19.789] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_TRIES' not set
  [12:36:19.789] Set package option 'parallelly.makeNodePSOCK.tries.delay'
  [12:36:19.789] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_TRIES_DELAY' not set
  [12:36:19.790] Set package option 'parallelly.makeNodePSOCK.rscript_label'
  [12:36:19.790] R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL='TRUE'
  [12:36:19.790] => options("parallelly.makeNodePSOCK.rscript_label" = 'TRUE') [n=1, mode=character]
  [12:36:19.791] Set package option 'parallelly.makeNodePSOCK.sessionInfo.pkgs'
  [12:36:19.791] R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS='TRUE'
  [12:36:19.791] => options("parallelly.makeNodePSOCK.sessionInfo.pkgs" = 'TRUE') [n=1, mode=character]
  [12:36:19.791] Set package option 'parallelly.makeNodePSOCK.autoKill'
  [12:36:19.792] R_PARALLELLY_MAKENODEPSOCK_AUTOKILL='TRUE'
  [12:36:19.792] Coercing from character to logical: 'TRUE'
  [12:36:19.792] => options("parallelly.makeNodePSOCK.autoKill" = 'TRUE') [n=1, mode=logical]
  [12:36:19.792] Set package option 'parallelly.makeNodePSOCK.master.localhost.hostname'
  [12:36:19.793] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_MASTER_LOCALHOST_HOSTNAME' not set
  [12:36:19.793] Set package option 'parallelly.makeNodePSOCK.port.increment'
  [12:36:19.793] Environment variable 'R_PARALLELLY_MAKENODEPSOCK_PORT_INCREMENT' not set
  [12:36:19.795] parallelly-specific environment variables:
  - R_PARALLELLY_MAKENODEPSOCK_AUTOKILL='TRUE'
  - R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT='120'
  - R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL='TRUE'
  - R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS='TRUE'
  - R_PARALLELLY_MAKENODEPSOCK_TIMEOUT='120'
  - R_PARALLELLY_RANDOM_PORTS='20000:39999'
  [12:36:19.803] Future-specific environment variables:
  [12:36:19.804] Environment variable 'R_FUTURE_DEMO_MANDELBROT_REGION' not set
  [12:36:19.804] Environment variable 'R_FUTURE_DEMO_MANDELBROT_NROW' not set
  [12:36:19.804] Environment variable 'R_FUTURE_DEPRECATED_IGNORE' not set
  [12:36:19.804] Environment variable 'R_FUTURE_DEPRECATED_DEFUNCT' not set
  [12:36:19.804] Environment variable 'R_FUTURE_FORK_MULTITHREADING_ENABLE' not set
  [12:36:19.805] Environment variable 'R_FUTURE_GLOBALS_MAXSIZE' not set
  [12:36:19.805] Environment variable 'R_FUTURE_GLOBALS_ONMISSING' not set
  [12:36:19.805] Environment variable 'R_FUTURE_GLOBALS_ONREFERENCE' not set
  [12:36:19.805] Environment variable 'R_FUTURE_GLOBALS_METHOD' not set
  [12:36:19.805] Environment variable 'R_FUTURE_GLOBALS_RESOLVE' not set
  [12:36:19.806] Environment variable 'R_FUTURE_LAZY_ASSERTOWNER' not set
  [12:36:19.806] Environment variable 'R_FUTURE_PLAN' not set
  [12:36:19.806] Environment variable 'R_FUTURE_PLAN_DISALLOW' not set
  [12:36:19.806] Environment variable 'R_FUTURE_PSOCK_RELAY_IMMEDIATE' not set
  [12:36:19.806] Environment variable 'R_FUTURE_RELAY_IMMEDIATE' not set
  [12:36:19.806] Environment variable 'R_FUTURE_RESOLVE_RECURSIVE' not set
  [12:36:19.807] Environment variable 'R_FUTURE_ALIVE_TIMEOUT' not set
  [12:36:19.807] Environment variable 'R_FUTURE_RESOLVED_TIMEOUT' not set
  [12:36:19.807] Environment variable 'R_FUTURE_CLUSTER_RESOLVED_TIMEOUT' not set
  [12:36:19.807] Environment variable 'R_FUTURE_MULTICORE_RESOLVED_TIMEOUT' not set
  [12:36:19.807] Environment variable 'R_FUTURE_ONFUTURECONDITION_KEEPFUTURE' not set
  [12:36:19.807] Environment variable 'R_FUTURE_RNG_ONMISUSE' not set
  [12:36:19.808] Environment variable 'R_FUTURE_GLOBALENV_ONMISUSE' not set
  [12:36:19.808] Environment variable 'R_FUTURE_WAIT_TIMEOUT' not set
  [12:36:19.808] Environment variable 'R_FUTURE_WAIT_INTERVAL' not set
  [12:36:19.808] Environment variable 'R_FUTURE_WAIT_ALPHA' not set
  [12:36:19.808] Environment variable 'R_FUTURE_ASSIGN_GLOBALS_EXCLUDE' not set
  [12:36:19.809] Environment variable 'R_FUTURE_OUTPUT_WINDOWS_REENCODE' not set
  [12:36:19.809] Environment variable 'R_FUTURE_GLOBALS_GLOBALSOF_LOCALS' not set
  [12:36:19.809] Environment variable 'R_FUTURE_STATE_ONINVALID' not set
  [12:36:19.809] Environment variable 'R_FUTURE_JOURNAL' not set
  [12:36:19.809] Environment variable 'R_FUTURE_GLOBALS_KEEPWHERE' not set
  [12:36:19.810] R process uuid: 2deb4ff0-b443-53ef-486e-15cb818a2426
  [12:36:19.811] Setting plan('default')
  [12:36:19.811] plan(): Setting new future strategy stack:
  [12:36:19.811] List of future strategies:
  [12:36:19.811] 1. sequential:
  [12:36:19.811]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
  [12:36:19.811]    - tweaked: FALSE
  [12:36:19.811]    - call: NULL
  [12:36:19.813] plan(): nbrOfWorkers() = 1
  [12:36:19.878] plan(): Setting new future strategy stack:
  [12:36:19.878] List of future strategies:
  [12:36:19.878] 1. mirai_multisession:
  [12:36:19.878]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:19.878]    - tweaked: FALSE
  [12:36:19.878]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:19.895] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:19.895] < mirai [$data] >
  [12:36:19.900] getGlobalsAndPackages() ...
  [12:36:19.901] Not searching for globals
  [12:36:19.901] - globals: [0] <none>
  [12:36:19.901] getGlobalsAndPackages() ... DONE
  [12:36:19.902] getGlobalsAndPackages() ...
  [12:36:19.902] 
  [12:36:19.902] - globals: [0] <none>
  [12:36:19.902] getGlobalsAndPackages() ... DONE
  [12:36:20.289] Packages needed by the future expression (n = 0): <none>
  [12:36:20.289] Packages needed by future strategies (n = 0): <none>
  [12:36:20.291] {
  [12:36:20.291]     {
  [12:36:20.291]         {
  [12:36:20.291]             ...future.startTime <- base::Sys.time()
  [12:36:20.291]             {
  [12:36:20.291]                 {
  [12:36:20.291]                   {
  [12:36:20.291]                     base::local({
  [12:36:20.291]                       has_future <- base::requireNamespace("future", 
  [12:36:20.291]                         quietly = TRUE)
  [12:36:20.291]                       if (has_future) {
  [12:36:20.291]                         ns <- base::getNamespace("future")
  [12:36:20.291]                         version <- ns[[".package"]][["version"]]
  [12:36:20.291]                         if (is.null(version)) 
  [12:36:20.291]                           version <- utils::packageVersion("future")
  [12:36:20.291]                       }
  [12:36:20.291]                       else {
  [12:36:20.291]                         version <- NULL
  [12:36:20.291]                       }
  [12:36:20.291]                       if (!has_future || version < "1.8.0") {
  [12:36:20.291]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:20.291]                           "", base::R.version$version.string), 
  [12:36:20.291]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:20.291]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:20.291]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:20.291]                             "release", "version")], collapse = " "), 
  [12:36:20.291]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:20.291]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:20.291]                           info)
  [12:36:20.291]                         info <- base::paste(info, collapse = "; ")
  [12:36:20.291]                         if (!has_future) {
  [12:36:20.291]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:20.291]                             info)
  [12:36:20.291]                         }
  [12:36:20.291]                         else {
  [12:36:20.291]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:20.291]                             info, version)
  [12:36:20.291]                         }
  [12:36:20.291]                         base::stop(msg)
  [12:36:20.291]                       }
  [12:36:20.291]                     })
  [12:36:20.291]                   }
  [12:36:20.291]                   ...future.strategy.old <- future::plan("list")
  [12:36:20.291]                   options(future.plan = NULL)
  [12:36:20.291]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:20.291]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:20.291]                 }
  [12:36:20.291]                 ...future.workdir <- getwd()
  [12:36:20.291]             }
  [12:36:20.291]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:20.291]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:20.291]         }
  [12:36:20.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:20.291]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:20.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:20.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:20.291]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:20.291]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:20.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:20.291]             base::names(...future.oldOptions))
  [12:36:20.291]     }
  [12:36:20.291]     if (FALSE) {
  [12:36:20.291]     }
  [12:36:20.291]     else {
  [12:36:20.291]         if (TRUE) {
  [12:36:20.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:20.291]                 open = "w")
  [12:36:20.291]         }
  [12:36:20.291]         else {
  [12:36:20.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:20.291]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:20.291]         }
  [12:36:20.291]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:20.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:20.291]             base::sink(type = "output", split = FALSE)
  [12:36:20.291]             base::close(...future.stdout)
  [12:36:20.291]         }, add = TRUE)
  [12:36:20.291]     }
  [12:36:20.291]     ...future.frame <- base::sys.nframe()
  [12:36:20.291]     ...future.conditions <- base::list()
  [12:36:20.291]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:20.291]     if (FALSE) {
  [12:36:20.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:20.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:20.291]     }
  [12:36:20.291]     ...future.result <- base::tryCatch({
  [12:36:20.291]         base::withCallingHandlers({
  [12:36:20.291]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:20.291]             future::FutureResult(value = ...future.value$value, 
  [12:36:20.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:20.291]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:20.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:20.291]                     ...future.globalenv.names))
  [12:36:20.291]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:20.291]         }, condition = base::local({
  [12:36:20.291]             c <- base::c
  [12:36:20.291]             inherits <- base::inherits
  [12:36:20.291]             invokeRestart <- base::invokeRestart
  [12:36:20.291]             length <- base::length
  [12:36:20.291]             list <- base::list
  [12:36:20.291]             seq.int <- base::seq.int
  [12:36:20.291]             signalCondition <- base::signalCondition
  [12:36:20.291]             sys.calls <- base::sys.calls
  [12:36:20.291]             `[[` <- base::`[[`
  [12:36:20.291]             `+` <- base::`+`
  [12:36:20.291]             `<<-` <- base::`<<-`
  [12:36:20.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:20.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:20.291]                   3L)]
  [12:36:20.291]             }
  [12:36:20.291]             function(cond) {
  [12:36:20.291]                 is_error <- inherits(cond, "error")
  [12:36:20.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:20.291]                   NULL)
  [12:36:20.291]                 if (is_error) {
  [12:36:20.291]                   sessionInformation <- function() {
  [12:36:20.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:20.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:20.291]                       search = base::search(), system = base::Sys.info())
  [12:36:20.291]                   }
  [12:36:20.291]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:20.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:20.291]                     cond$call), session = sessionInformation(), 
  [12:36:20.291]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:20.291]                   signalCondition(cond)
  [12:36:20.291]                 }
  [12:36:20.291]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:20.291]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:20.291]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:20.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:20.291]                   if (FALSE && !signal) {
  [12:36:20.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:20.291]                     {
  [12:36:20.291]                       inherits <- base::inherits
  [12:36:20.291]                       invokeRestart <- base::invokeRestart
  [12:36:20.291]                       is.null <- base::is.null
  [12:36:20.291]                       muffled <- FALSE
  [12:36:20.291]                       if (inherits(cond, "message")) {
  [12:36:20.291]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:20.291]                         if (muffled) 
  [12:36:20.291]                           invokeRestart("muffleMessage")
  [12:36:20.291]                       }
  [12:36:20.291]                       else if (inherits(cond, "warning")) {
  [12:36:20.291]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:20.291]                         if (muffled) 
  [12:36:20.291]                           invokeRestart("muffleWarning")
  [12:36:20.291]                       }
  [12:36:20.291]                       else if (inherits(cond, "condition")) {
  [12:36:20.291]                         if (!is.null(pattern)) {
  [12:36:20.291]                           computeRestarts <- base::computeRestarts
  [12:36:20.291]                           grepl <- base::grepl
  [12:36:20.291]                           restarts <- computeRestarts(cond)
  [12:36:20.291]                           for (restart in restarts) {
  [12:36:20.291]                             name <- restart$name
  [12:36:20.291]                             if (is.null(name)) 
  [12:36:20.291]                               next
  [12:36:20.291]                             if (!grepl(pattern, name)) 
  [12:36:20.291]                               next
  [12:36:20.291]                             invokeRestart(restart)
  [12:36:20.291]                             muffled <- TRUE
  [12:36:20.291]                             break
  [12:36:20.291]                           }
  [12:36:20.291]                         }
  [12:36:20.291]                       }
  [12:36:20.291]                       invisible(muffled)
  [12:36:20.291]                     }
  [12:36:20.291]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:20.291]                   }
  [12:36:20.291]                 }
  [12:36:20.291]                 else {
  [12:36:20.291]                   if (TRUE) {
  [12:36:20.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:20.291]                     {
  [12:36:20.291]                       inherits <- base::inherits
  [12:36:20.291]                       invokeRestart <- base::invokeRestart
  [12:36:20.291]                       is.null <- base::is.null
  [12:36:20.291]                       muffled <- FALSE
  [12:36:20.291]                       if (inherits(cond, "message")) {
  [12:36:20.291]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:20.291]                         if (muffled) 
  [12:36:20.291]                           invokeRestart("muffleMessage")
  [12:36:20.291]                       }
  [12:36:20.291]                       else if (inherits(cond, "warning")) {
  [12:36:20.291]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:20.291]                         if (muffled) 
  [12:36:20.291]                           invokeRestart("muffleWarning")
  [12:36:20.291]                       }
  [12:36:20.291]                       else if (inherits(cond, "condition")) {
  [12:36:20.291]                         if (!is.null(pattern)) {
  [12:36:20.291]                           computeRestarts <- base::computeRestarts
  [12:36:20.291]                           grepl <- base::grepl
  [12:36:20.291]                           restarts <- computeRestarts(cond)
  [12:36:20.291]                           for (restart in restarts) {
  [12:36:20.291]                             name <- restart$name
  [12:36:20.291]                             if (is.null(name)) 
  [12:36:20.291]                               next
  [12:36:20.291]                             if (!grepl(pattern, name)) 
  [12:36:20.291]                               next
  [12:36:20.291]                             invokeRestart(restart)
  [12:36:20.291]                             muffled <- TRUE
  [12:36:20.291]                             break
  [12:36:20.291]                           }
  [12:36:20.291]                         }
  [12:36:20.291]                       }
  [12:36:20.291]                       invisible(muffled)
  [12:36:20.291]                     }
  [12:36:20.291]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:20.291]                   }
  [12:36:20.291]                 }
  [12:36:20.291]             }
  [12:36:20.291]         }))
  [12:36:20.291]     }, error = function(ex) {
  [12:36:20.291]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:20.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:20.291]                 ...future.rng), started = ...future.startTime, 
  [12:36:20.291]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:20.291]             version = "1.8"), class = "FutureResult")
  [12:36:20.291]     }, finally = {
  [12:36:20.291]         if (!identical(...future.workdir, getwd())) 
  [12:36:20.291]             setwd(...future.workdir)
  [12:36:20.291]         {
  [12:36:20.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:20.291]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:20.291]             }
  [12:36:20.291]             base::options(...future.oldOptions)
  [12:36:20.291]             if (.Platform$OS.type == "windows") {
  [12:36:20.291]                 old_names <- names(...future.oldEnvVars)
  [12:36:20.291]                 envs <- base::Sys.getenv()
  [12:36:20.291]                 names <- names(envs)
  [12:36:20.291]                 common <- intersect(names, old_names)
  [12:36:20.291]                 added <- setdiff(names, old_names)
  [12:36:20.291]                 removed <- setdiff(old_names, names)
  [12:36:20.291]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:20.291]                   envs[common]]
  [12:36:20.291]                 NAMES <- toupper(changed)
  [12:36:20.291]                 args <- list()
  [12:36:20.291]                 for (kk in seq_along(NAMES)) {
  [12:36:20.291]                   name <- changed[[kk]]
  [12:36:20.291]                   NAME <- NAMES[[kk]]
  [12:36:20.291]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:20.291]                     next
  [12:36:20.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:20.291]                 }
  [12:36:20.291]                 NAMES <- toupper(added)
  [12:36:20.291]                 for (kk in seq_along(NAMES)) {
  [12:36:20.291]                   name <- added[[kk]]
  [12:36:20.291]                   NAME <- NAMES[[kk]]
  [12:36:20.291]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:20.291]                     next
  [12:36:20.291]                   args[[name]] <- ""
  [12:36:20.291]                 }
  [12:36:20.291]                 NAMES <- toupper(removed)
  [12:36:20.291]                 for (kk in seq_along(NAMES)) {
  [12:36:20.291]                   name <- removed[[kk]]
  [12:36:20.291]                   NAME <- NAMES[[kk]]
  [12:36:20.291]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:20.291]                     next
  [12:36:20.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:20.291]                 }
  [12:36:20.291]                 if (length(args) > 0) 
  [12:36:20.291]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:20.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:20.291]             }
  [12:36:20.291]             else {
  [12:36:20.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:20.291]             }
  [12:36:20.291]             {
  [12:36:20.291]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:20.291]                   0L) {
  [12:36:20.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:20.291]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:20.291]                   base::options(opts)
  [12:36:20.291]                 }
  [12:36:20.291]                 {
  [12:36:20.291]                   NULL
  [12:36:20.291]                   options(future.plan = NULL)
  [12:36:20.291]                   if (is.na(NA_character_)) 
  [12:36:20.291]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:20.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:20.291]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:20.291]                     .init = FALSE)
  [12:36:20.291]                 }
  [12:36:20.291]             }
  [12:36:20.291]         }
  [12:36:20.291]     })
  [12:36:20.291]     if (TRUE) {
  [12:36:20.291]         base::sink(type = "output", split = FALSE)
  [12:36:20.291]         if (TRUE) {
  [12:36:20.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:20.291]         }
  [12:36:20.291]         else {
  [12:36:20.291]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:20.291]         }
  [12:36:20.291]         base::close(...future.stdout)
  [12:36:20.291]         ...future.stdout <- NULL
  [12:36:20.291]     }
  [12:36:20.291]     ...future.result$conditions <- ...future.conditions
  [12:36:20.291]     ...future.result$finished <- base::Sys.time()
  [12:36:20.291]     ...future.result
  [12:36:20.291] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/rng.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:20.770] plan(): Setting new future strategy stack:
  [12:36:20.772] List of future strategies:
  [12:36:20.772] 1. mirai_multisession:
  [12:36:20.772]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:20.772]    - tweaked: FALSE
  [12:36:20.772]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:20.792] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:20.792] < mirai [$data] >
  [12:36:20.800] getGlobalsAndPackages() ...
  [12:36:20.800] Not searching for globals
  [12:36:20.801] - globals: [0] <none>
  [12:36:20.801] getGlobalsAndPackages() ... DONE
  [12:36:20.802] getGlobalsAndPackages() ...
  [12:36:20.802] 
  [12:36:20.802] - globals: [0] <none>
  [12:36:20.803] getGlobalsAndPackages() ... DONE
  [12:36:21.245] Packages needed by the future expression (n = 0): <none>
  [12:36:21.245] Packages needed by future strategies (n = 0): <none>
  [12:36:21.248] {
  [12:36:21.248]     {
  [12:36:21.248]         {
  [12:36:21.248]             ...future.startTime <- base::Sys.time()
  [12:36:21.248]             {
  [12:36:21.248]                 {
  [12:36:21.248]                   {
  [12:36:21.248]                     base::local({
  [12:36:21.248]                       has_future <- base::requireNamespace("future", 
  [12:36:21.248]                         quietly = TRUE)
  [12:36:21.248]                       if (has_future) {
  [12:36:21.248]                         ns <- base::getNamespace("future")
  [12:36:21.248]                         version <- ns[[".package"]][["version"]]
  [12:36:21.248]                         if (is.null(version)) 
  [12:36:21.248]                           version <- utils::packageVersion("future")
  [12:36:21.248]                       }
  [12:36:21.248]                       else {
  [12:36:21.248]                         version <- NULL
  [12:36:21.248]                       }
  [12:36:21.248]                       if (!has_future || version < "1.8.0") {
  [12:36:21.248]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:21.248]                           "", base::R.version$version.string), 
  [12:36:21.248]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:21.248]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:21.248]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:21.248]                             "release", "version")], collapse = " "), 
  [12:36:21.248]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:21.248]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:21.248]                           info)
  [12:36:21.248]                         info <- base::paste(info, collapse = "; ")
  [12:36:21.248]                         if (!has_future) {
  [12:36:21.248]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:21.248]                             info)
  [12:36:21.248]                         }
  [12:36:21.248]                         else {
  [12:36:21.248]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:21.248]                             info, version)
  [12:36:21.248]                         }
  [12:36:21.248]                         base::stop(msg)
  [12:36:21.248]                       }
  [12:36:21.248]                     })
  [12:36:21.248]                   }
  [12:36:21.248]                   ...future.strategy.old <- future::plan("list")
  [12:36:21.248]                   options(future.plan = NULL)
  [12:36:21.248]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:21.248]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:21.248]                 }
  [12:36:21.248]                 ...future.workdir <- getwd()
  [12:36:21.248]             }
  [12:36:21.248]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:21.248]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:21.248]         }
  [12:36:21.248]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:21.248]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:21.248]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:21.248]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:21.248]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:21.248]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:21.248]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:21.248]             base::names(...future.oldOptions))
  [12:36:21.248]     }
  [12:36:21.248]     if (FALSE) {
  [12:36:21.248]     }
  [12:36:21.248]     else {
  [12:36:21.248]         if (TRUE) {
  [12:36:21.248]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:21.248]                 open = "w")
  [12:36:21.248]         }
  [12:36:21.248]         else {
  [12:36:21.248]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:21.248]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:21.248]         }
  [12:36:21.248]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:21.248]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:21.248]             base::sink(type = "output", split = FALSE)
  [12:36:21.248]             base::close(...future.stdout)
  [12:36:21.248]         }, add = TRUE)
  [12:36:21.248]     }
  [12:36:21.248]     ...future.frame <- base::sys.nframe()
  [12:36:21.248]     ...future.conditions <- base::list()
  [12:36:21.248]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:21.248]     if (FALSE) {
  [12:36:21.248]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:21.248]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:21.248]     }
  [12:36:21.248]     ...future.result <- base::tryCatch({
  [12:36:21.248]         base::withCallingHandlers({
  [12:36:21.248]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:21.248]             future::FutureResult(value = ...future.value$value, 
  [12:36:21.248]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:21.248]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:21.248]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:21.248]                     ...future.globalenv.names))
  [12:36:21.248]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:21.248]         }, condition = base::local({
  [12:36:21.248]             c <- base::c
  [12:36:21.248]             inherits <- base::inherits
  [12:36:21.248]             invokeRestart <- base::invokeRestart
  [12:36:21.248]             length <- base::length
  [12:36:21.248]             list <- base::list
  [12:36:21.248]             seq.int <- base::seq.int
  [12:36:21.248]             signalCondition <- base::signalCondition
  [12:36:21.248]             sys.calls <- base::sys.calls
  [12:36:21.248]             `[[` <- base::`[[`
  [12:36:21.248]             `+` <- base::`+`
  [12:36:21.248]             `<<-` <- base::`<<-`
  [12:36:21.248]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:21.248]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:21.248]                   3L)]
  [12:36:21.248]             }
  [12:36:21.248]             function(cond) {
  [12:36:21.248]                 is_error <- inherits(cond, "error")
  [12:36:21.248]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:21.248]                   NULL)
  [12:36:21.248]                 if (is_error) {
  [12:36:21.248]                   sessionInformation <- function() {
  [12:36:21.248]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:21.248]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:21.248]                       search = base::search(), system = base::Sys.info())
  [12:36:21.248]                   }
  [12:36:21.248]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:21.248]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:21.248]                     cond$call), session = sessionInformation(), 
  [12:36:21.248]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:21.248]                   signalCondition(cond)
  [12:36:21.248]                 }
  [12:36:21.248]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:21.248]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:21.248]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:21.248]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:21.248]                   if (FALSE && !signal) {
  [12:36:21.248]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:21.248]                     {
  [12:36:21.248]                       inherits <- base::inherits
  [12:36:21.248]                       invokeRestart <- base::invokeRestart
  [12:36:21.248]                       is.null <- base::is.null
  [12:36:21.248]                       muffled <- FALSE
  [12:36:21.248]                       if (inherits(cond, "message")) {
  [12:36:21.248]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:21.248]                         if (muffled) 
  [12:36:21.248]                           invokeRestart("muffleMessage")
  [12:36:21.248]                       }
  [12:36:21.248]                       else if (inherits(cond, "warning")) {
  [12:36:21.248]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:21.248]                         if (muffled) 
  [12:36:21.248]                           invokeRestart("muffleWarning")
  [12:36:21.248]                       }
  [12:36:21.248]                       else if (inherits(cond, "condition")) {
  [12:36:21.248]                         if (!is.null(pattern)) {
  [12:36:21.248]                           computeRestarts <- base::computeRestarts
  [12:36:21.248]                           grepl <- base::grepl
  [12:36:21.248]                           restarts <- computeRestarts(cond)
  [12:36:21.248]                           for (restart in restarts) {
  [12:36:21.248]                             name <- restart$name
  [12:36:21.248]                             if (is.null(name)) 
  [12:36:21.248]                               next
  [12:36:21.248]                             if (!grepl(pattern, name)) 
  [12:36:21.248]                               next
  [12:36:21.248]                             invokeRestart(restart)
  [12:36:21.248]                             muffled <- TRUE
  [12:36:21.248]                             break
  [12:36:21.248]                           }
  [12:36:21.248]                         }
  [12:36:21.248]                       }
  [12:36:21.248]                       invisible(muffled)
  [12:36:21.248]                     }
  [12:36:21.248]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:21.248]                   }
  [12:36:21.248]                 }
  [12:36:21.248]                 else {
  [12:36:21.248]                   if (TRUE) {
  [12:36:21.248]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:21.248]                     {
  [12:36:21.248]                       inherits <- base::inherits
  [12:36:21.248]                       invokeRestart <- base::invokeRestart
  [12:36:21.248]                       is.null <- base::is.null
  [12:36:21.248]                       muffled <- FALSE
  [12:36:21.248]                       if (inherits(cond, "message")) {
  [12:36:21.248]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:21.248]                         if (muffled) 
  [12:36:21.248]                           invokeRestart("muffleMessage")
  [12:36:21.248]                       }
  [12:36:21.248]                       else if (inherits(cond, "warning")) {
  [12:36:21.248]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:21.248]                         if (muffled) 
  [12:36:21.248]                           invokeRestart("muffleWarning")
  [12:36:21.248]                       }
  [12:36:21.248]                       else if (inherits(cond, "condition")) {
  [12:36:21.248]                         if (!is.null(pattern)) {
  [12:36:21.248]                           computeRestarts <- base::computeRestarts
  [12:36:21.248]                           grepl <- base::grepl
  [12:36:21.248]                           restarts <- computeRestarts(cond)
  [12:36:21.248]                           for (restart in restarts) {
  [12:36:21.248]                             name <- restart$name
  [12:36:21.248]                             if (is.null(name)) 
  [12:36:21.248]                               next
  [12:36:21.248]                             if (!grepl(pattern, name)) 
  [12:36:21.248]                               next
  [12:36:21.248]                             invokeRestart(restart)
  [12:36:21.248]                             muffled <- TRUE
  [12:36:21.248]                             break
  [12:36:21.248]                           }
  [12:36:21.248]                         }
  [12:36:21.248]                       }
  [12:36:21.248]                       invisible(muffled)
  [12:36:21.248]                     }
  [12:36:21.248]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:21.248]                   }
  [12:36:21.248]                 }
  [12:36:21.248]             }
  [12:36:21.248]         }))
  [12:36:21.248]     }, error = function(ex) {
  [12:36:21.248]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:21.248]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:21.248]                 ...future.rng), started = ...future.startTime, 
  [12:36:21.248]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:21.248]             version = "1.8"), class = "FutureResult")
  [12:36:21.248]     }, finally = {
  [12:36:21.248]         if (!identical(...future.workdir, getwd())) 
  [12:36:21.248]             setwd(...future.workdir)
  [12:36:21.248]         {
  [12:36:21.248]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:21.248]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:21.248]             }
  [12:36:21.248]             base::options(...future.oldOptions)
  [12:36:21.248]             if (.Platform$OS.type == "windows") {
  [12:36:21.248]                 old_names <- names(...future.oldEnvVars)
  [12:36:21.248]                 envs <- base::Sys.getenv()
  [12:36:21.248]                 names <- names(envs)
  [12:36:21.248]                 common <- intersect(names, old_names)
  [12:36:21.248]                 added <- setdiff(names, old_names)
  [12:36:21.248]                 removed <- setdiff(old_names, names)
  [12:36:21.248]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:21.248]                   envs[common]]
  [12:36:21.248]                 NAMES <- toupper(changed)
  [12:36:21.248]                 args <- list()
  [12:36:21.248]                 for (kk in seq_along(NAMES)) {
  [12:36:21.248]                   name <- changed[[kk]]
  [12:36:21.248]                   NAME <- NAMES[[kk]]
  [12:36:21.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:21.248]                     next
  [12:36:21.248]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:21.248]                 }
  [12:36:21.248]                 NAMES <- toupper(added)
  [12:36:21.248]                 for (kk in seq_along(NAMES)) {
  [12:36:21.248]                   name <- added[[kk]]
  [12:36:21.248]                   NAME <- NAMES[[kk]]
  [12:36:21.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:21.248]                     next
  [12:36:21.248]                   args[[name]] <- ""
  [12:36:21.248]                 }
  [12:36:21.248]                 NAMES <- toupper(removed)
  [12:36:21.248]                 for (kk in seq_along(NAMES)) {
  [12:36:21.248]                   name <- removed[[kk]]
  [12:36:21.248]                   NAME <- NAMES[[kk]]
  [12:36:21.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:21.248]                     next
  [12:36:21.248]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:21.248]                 }
  [12:36:21.248]                 if (length(args) > 0) 
  [12:36:21.248]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:21.248]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:21.248]             }
  [12:36:21.248]             else {
  [12:36:21.248]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:21.248]             }
  [12:36:21.248]             {
  [12:36:21.248]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:21.248]                   0L) {
  [12:36:21.248]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:21.248]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:21.248]                   base::options(opts)
  [12:36:21.248]                 }
  [12:36:21.248]                 {
  [12:36:21.248]                   NULL
  [12:36:21.248]                   options(future.plan = NULL)
  [12:36:21.248]                   if (is.na(NA_character_)) 
  [12:36:21.248]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:21.248]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:21.248]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:21.248]                     .init = FALSE)
  [12:36:21.248]                 }
  [12:36:21.248]             }
  [12:36:21.248]         }
  [12:36:21.248]     })
  [12:36:21.248]     if (TRUE) {
  [12:36:21.248]         base::sink(type = "output", split = FALSE)
  [12:36:21.248]         if (TRUE) {
  [12:36:21.248]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:21.248]         }
  [12:36:21.248]         else {
  [12:36:21.248]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:21.248]         }
  [12:36:21.248]         base::close(...future.stdout)
  [12:36:21.248]         ...future.stdout <- NULL
  [12:36:21.248]     }
  [12:36:21.248]     ...future.result$conditions <- ...future.conditions
  [12:36:21.248]     ...future.result$finished <- base::Sys.time()
  [12:36:21.248]     ...future.result
  [12:36:21.248] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/stdout.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  [12:36:21.812] plan(): Setting new future strategy stack:
  [12:36:21.814] List of future strategies:
  [12:36:21.814] 1. mirai_multisession:
  [12:36:21.814]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:21.814]    - tweaked: FALSE
  [12:36:21.814]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:21.835] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:21.836] < mirai [$data] >
  [12:36:21.843] getGlobalsAndPackages() ...
  [12:36:21.844] Not searching for globals
  [12:36:21.844] - globals: [0] <none>
  [12:36:21.844] getGlobalsAndPackages() ... DONE
  [12:36:21.845] getGlobalsAndPackages() ...
  [12:36:21.845] 
  [12:36:21.846] - globals: [0] <none>
  [12:36:21.846] getGlobalsAndPackages() ... DONE
  [12:36:22.247] Packages needed by the future expression (n = 0): <none>
  [12:36:22.247] Packages needed by future strategies (n = 0): <none>
  [12:36:22.248] {
  [12:36:22.248]     {
  [12:36:22.248]         {
  [12:36:22.248]             ...future.startTime <- base::Sys.time()
  [12:36:22.248]             {
  [12:36:22.248]                 {
  [12:36:22.248]                   {
  [12:36:22.248]                     base::local({
  [12:36:22.248]                       has_future <- base::requireNamespace("future", 
  [12:36:22.248]                         quietly = TRUE)
  [12:36:22.248]                       if (has_future) {
  [12:36:22.248]                         ns <- base::getNamespace("future")
  [12:36:22.248]                         version <- ns[[".package"]][["version"]]
  [12:36:22.248]                         if (is.null(version)) 
  [12:36:22.248]                           version <- utils::packageVersion("future")
  [12:36:22.248]                       }
  [12:36:22.248]                       else {
  [12:36:22.248]                         version <- NULL
  [12:36:22.248]                       }
  [12:36:22.248]                       if (!has_future || version < "1.8.0") {
  [12:36:22.248]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:22.248]                           "", base::R.version$version.string), 
  [12:36:22.248]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:22.248]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:22.248]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:22.248]                             "release", "version")], collapse = " "), 
  [12:36:22.248]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:22.248]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:22.248]                           info)
  [12:36:22.248]                         info <- base::paste(info, collapse = "; ")
  [12:36:22.248]                         if (!has_future) {
  [12:36:22.248]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:22.248]                             info)
  [12:36:22.248]                         }
  [12:36:22.248]                         else {
  [12:36:22.248]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:22.248]                             info, version)
  [12:36:22.248]                         }
  [12:36:22.248]                         base::stop(msg)
  [12:36:22.248]                       }
  [12:36:22.248]                     })
  [12:36:22.248]                   }
  [12:36:22.248]                   ...future.strategy.old <- future::plan("list")
  [12:36:22.248]                   options(future.plan = NULL)
  [12:36:22.248]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:22.248]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:22.248]                 }
  [12:36:22.248]                 ...future.workdir <- getwd()
  [12:36:22.248]             }
  [12:36:22.248]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:22.248]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:22.248]         }
  [12:36:22.248]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:22.248]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:22.248]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:22.248]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:22.248]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:22.248]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:22.248]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:22.248]             base::names(...future.oldOptions))
  [12:36:22.248]     }
  [12:36:22.248]     if (FALSE) {
  [12:36:22.248]     }
  [12:36:22.248]     else {
  [12:36:22.248]         if (TRUE) {
  [12:36:22.248]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:22.248]                 open = "w")
  [12:36:22.248]         }
  [12:36:22.248]         else {
  [12:36:22.248]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:22.248]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:22.248]         }
  [12:36:22.248]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:22.248]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:22.248]             base::sink(type = "output", split = FALSE)
  [12:36:22.248]             base::close(...future.stdout)
  [12:36:22.248]         }, add = TRUE)
  [12:36:22.248]     }
  [12:36:22.248]     ...future.frame <- base::sys.nframe()
  [12:36:22.248]     ...future.conditions <- base::list()
  [12:36:22.248]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:22.248]     if (FALSE) {
  [12:36:22.248]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:22.248]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:22.248]     }
  [12:36:22.248]     ...future.result <- base::tryCatch({
  [12:36:22.248]         base::withCallingHandlers({
  [12:36:22.248]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:22.248]             future::FutureResult(value = ...future.value$value, 
  [12:36:22.248]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:22.248]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:22.248]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:22.248]                     ...future.globalenv.names))
  [12:36:22.248]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:22.248]         }, condition = base::local({
  [12:36:22.248]             c <- base::c
  [12:36:22.248]             inherits <- base::inherits
  [12:36:22.248]             invokeRestart <- base::invokeRestart
  [12:36:22.248]             length <- base::length
  [12:36:22.248]             list <- base::list
  [12:36:22.248]             seq.int <- base::seq.int
  [12:36:22.248]             signalCondition <- base::signalCondition
  [12:36:22.248]             sys.calls <- base::sys.calls
  [12:36:22.248]             `[[` <- base::`[[`
  [12:36:22.248]             `+` <- base::`+`
  [12:36:22.248]             `<<-` <- base::`<<-`
  [12:36:22.248]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:22.248]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:22.248]                   3L)]
  [12:36:22.248]             }
  [12:36:22.248]             function(cond) {
  [12:36:22.248]                 is_error <- inherits(cond, "error")
  [12:36:22.248]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:22.248]                   NULL)
  [12:36:22.248]                 if (is_error) {
  [12:36:22.248]                   sessionInformation <- function() {
  [12:36:22.248]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:22.248]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:22.248]                       search = base::search(), system = base::Sys.info())
  [12:36:22.248]                   }
  [12:36:22.248]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:22.248]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:22.248]                     cond$call), session = sessionInformation(), 
  [12:36:22.248]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:22.248]                   signalCondition(cond)
  [12:36:22.248]                 }
  [12:36:22.248]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:22.248]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:22.248]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:22.248]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:22.248]                   if (FALSE && !signal) {
  [12:36:22.248]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:22.248]                     {
  [12:36:22.248]                       inherits <- base::inherits
  [12:36:22.248]                       invokeRestart <- base::invokeRestart
  [12:36:22.248]                       is.null <- base::is.null
  [12:36:22.248]                       muffled <- FALSE
  [12:36:22.248]                       if (inherits(cond, "message")) {
  [12:36:22.248]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:22.248]                         if (muffled) 
  [12:36:22.248]                           invokeRestart("muffleMessage")
  [12:36:22.248]                       }
  [12:36:22.248]                       else if (inherits(cond, "warning")) {
  [12:36:22.248]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:22.248]                         if (muffled) 
  [12:36:22.248]                           invokeRestart("muffleWarning")
  [12:36:22.248]                       }
  [12:36:22.248]                       else if (inherits(cond, "condition")) {
  [12:36:22.248]                         if (!is.null(pattern)) {
  [12:36:22.248]                           computeRestarts <- base::computeRestarts
  [12:36:22.248]                           grepl <- base::grepl
  [12:36:22.248]                           restarts <- computeRestarts(cond)
  [12:36:22.248]                           for (restart in restarts) {
  [12:36:22.248]                             name <- restart$name
  [12:36:22.248]                             if (is.null(name)) 
  [12:36:22.248]                               next
  [12:36:22.248]                             if (!grepl(pattern, name)) 
  [12:36:22.248]                               next
  [12:36:22.248]                             invokeRestart(restart)
  [12:36:22.248]                             muffled <- TRUE
  [12:36:22.248]                             break
  [12:36:22.248]                           }
  [12:36:22.248]                         }
  [12:36:22.248]                       }
  [12:36:22.248]                       invisible(muffled)
  [12:36:22.248]                     }
  [12:36:22.248]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:22.248]                   }
  [12:36:22.248]                 }
  [12:36:22.248]                 else {
  [12:36:22.248]                   if (TRUE) {
  [12:36:22.248]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:22.248]                     {
  [12:36:22.248]                       inherits <- base::inherits
  [12:36:22.248]                       invokeRestart <- base::invokeRestart
  [12:36:22.248]                       is.null <- base::is.null
  [12:36:22.248]                       muffled <- FALSE
  [12:36:22.248]                       if (inherits(cond, "message")) {
  [12:36:22.248]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:22.248]                         if (muffled) 
  [12:36:22.248]                           invokeRestart("muffleMessage")
  [12:36:22.248]                       }
  [12:36:22.248]                       else if (inherits(cond, "warning")) {
  [12:36:22.248]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:22.248]                         if (muffled) 
  [12:36:22.248]                           invokeRestart("muffleWarning")
  [12:36:22.248]                       }
  [12:36:22.248]                       else if (inherits(cond, "condition")) {
  [12:36:22.248]                         if (!is.null(pattern)) {
  [12:36:22.248]                           computeRestarts <- base::computeRestarts
  [12:36:22.248]                           grepl <- base::grepl
  [12:36:22.248]                           restarts <- computeRestarts(cond)
  [12:36:22.248]                           for (restart in restarts) {
  [12:36:22.248]                             name <- restart$name
  [12:36:22.248]                             if (is.null(name)) 
  [12:36:22.248]                               next
  [12:36:22.248]                             if (!grepl(pattern, name)) 
  [12:36:22.248]                               next
  [12:36:22.248]                             invokeRestart(restart)
  [12:36:22.248]                             muffled <- TRUE
  [12:36:22.248]                             break
  [12:36:22.248]                           }
  [12:36:22.248]                         }
  [12:36:22.248]                       }
  [12:36:22.248]                       invisible(muffled)
  [12:36:22.248]                     }
  [12:36:22.248]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:22.248]                   }
  [12:36:22.248]                 }
  [12:36:22.248]             }
  [12:36:22.248]         }))
  [12:36:22.248]     }, error = function(ex) {
  [12:36:22.248]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:22.248]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:22.248]                 ...future.rng), started = ...future.startTime, 
  [12:36:22.248]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:22.248]             version = "1.8"), class = "FutureResult")
  [12:36:22.248]     }, finally = {
  [12:36:22.248]         if (!identical(...future.workdir, getwd())) 
  [12:36:22.248]             setwd(...future.workdir)
  [12:36:22.248]         {
  [12:36:22.248]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:22.248]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:22.248]             }
  [12:36:22.248]             base::options(...future.oldOptions)
  [12:36:22.248]             if (.Platform$OS.type == "windows") {
  [12:36:22.248]                 old_names <- names(...future.oldEnvVars)
  [12:36:22.248]                 envs <- base::Sys.getenv()
  [12:36:22.248]                 names <- names(envs)
  [12:36:22.248]                 common <- intersect(names, old_names)
  [12:36:22.248]                 added <- setdiff(names, old_names)
  [12:36:22.248]                 removed <- setdiff(old_names, names)
  [12:36:22.248]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:22.248]                   envs[common]]
  [12:36:22.248]                 NAMES <- toupper(changed)
  [12:36:22.248]                 args <- list()
  [12:36:22.248]                 for (kk in seq_along(NAMES)) {
  [12:36:22.248]                   name <- changed[[kk]]
  [12:36:22.248]                   NAME <- NAMES[[kk]]
  [12:36:22.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:22.248]                     next
  [12:36:22.248]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:22.248]                 }
  [12:36:22.248]                 NAMES <- toupper(added)
  [12:36:22.248]                 for (kk in seq_along(NAMES)) {
  [12:36:22.248]                   name <- added[[kk]]
  [12:36:22.248]                   NAME <- NAMES[[kk]]
  [12:36:22.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:22.248]                     next
  [12:36:22.248]                   args[[name]] <- ""
  [12:36:22.248]                 }
  [12:36:22.248]                 NAMES <- toupper(removed)
  [12:36:22.248]                 for (kk in seq_along(NAMES)) {
  [12:36:22.248]                   name <- removed[[kk]]
  [12:36:22.248]                   NAME <- NAMES[[kk]]
  [12:36:22.248]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:22.248]                     next
  [12:36:22.248]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:22.248]                 }
  [12:36:22.248]                 if (length(args) > 0) 
  [12:36:22.248]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:22.248]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:22.248]             }
  [12:36:22.248]             else {
  [12:36:22.248]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:22.248]             }
  [12:36:22.248]             {
  [12:36:22.248]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:22.248]                   0L) {
  [12:36:22.248]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:22.248]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:22.248]                   base::options(opts)
  [12:36:22.248]                 }
  [12:36:22.248]                 {
  [12:36:22.248]                   NULL
  [12:36:22.248]                   options(future.plan = NULL)
  [12:36:22.248]                   if (is.na(NA_character_)) 
  [12:36:22.248]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:22.248]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:22.248]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:22.248]                     .init = FALSE)
  [12:36:22.248]                 }
  [12:36:22.248]             }
  [12:36:22.248]         }
  [12:36:22.248]     })
  [12:36:22.248]     if (TRUE) {
  [12:36:22.248]         base::sink(type = "output", split = FALSE)
  [12:36:22.248]         if (TRUE) {
  [12:36:22.248]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:22.248]         }
  [12:36:22.248]         else {
  [12:36:22.248]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:22.248]         }
  [12:36:22.248]         base::close(...future.stdout)
  [12:36:22.248]         ...future.stdout <- NULL
  [12:36:22.248]     }
  [12:36:22.248]     ...future.result$conditions <- ...future.conditions
  [12:36:22.248]     ...future.result$finished <- base::Sys.time()
  [12:36:22.248]     ...future.result
  [12:36:22.248] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
Running the tests in 'tests/zzz,future_lapply.R' failed.
Complete output:
  > ## This requires mirai (>= 0.13.2)
  > if (packageVersion("mirai") >= "0.13.2") {
  + 
  + source("incl/start.R")
  + library("listenv")
  + 
  + if (requireNamespace("future.apply", quietly = TRUE)) {
  +   future_lapply <- future.apply::future_lapply
  +   
  +   strategies <- c("mirai_multisession")
  +   
  +   message("*** future_lapply() ...")
  +   
  +   message("- future_lapply(x, FUN = vector, ...) ...")
  +   
  +   x <- list(a = "integer", c = "character", c = "list")
  +   str(list(x = x))
  +   
  +   y0 <- lapply(x, FUN = vector, length = 2L)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...", strategy)
  +     plan(strategy)
  +     stopifnot(nbrOfWorkers() < Inf)
  +     
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = vector, length = 2L,
  +                          future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN = base::vector, ...) ...")
  +   
  +   x <- list(a = "integer", c = "character", c = "list")
  +   str(list(x = x))
  +   
  +   y0 <- lapply(x, FUN = base::vector, length = 2L)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...", strategy)
  +     plan(strategy)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = base::vector, length = 2L,
  +                          future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   message("- future_lapply(x, FUN = future:::hpaste, ...) ...")
  +   
  +   x <- list(a = c("hello", b = 1:100))
  +   str(list(x = x))
  +   
  +   y0 <- lapply(x, FUN = future:::hpaste, collapse = "; ", maxHead = 3L)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...", strategy)
  +     plan(strategy)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = future:::hpaste, collapse = "; ",
  +                          maxHead = 3L, future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN = listenv::listenv, ...) ...")
  +   
  +   x <- list()
  +   
  +   y <- listenv()
  +   y$A <- 3L
  +   x$a <- y
  +   
  +   y <- listenv()
  +   y$A <- 3L
  +   y$B <- c("hello", b = 1:100)
  +   x$b <- y
  +   
  +   print(x)
  +   
  +   y0 <- lapply(x, FUN = listenv::mapping)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...", strategy)
  +     plan(strategy)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = listenv::mapping, future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN, ...) for large length(x) ...")
  +   a <- 3.14
  +   x <- 1:1e6
  +   
  +   y <- future_lapply(x, FUN = function(z) sqrt(z + a))
  +   y <- unlist(y, use.names = FALSE)
  +   
  +   stopifnot(all.equal(y, sqrt(x + a)))
  +   
  +   
  +   message("- future_lapply() with global in non-attached package ...")
  +   library("tools")
  +   my_ext <- function(x) file_ext(x)
  +   y_truth <- lapply("abc.txt", FUN = my_ext)
  +   
  +   for (strategy in strategies) {
  +     plan(strategy)
  +     y <- future_lapply("abc.txt", FUN = my_ext)
  +     stopifnot(identical(y, y_truth))
  +   }
  +   
  +   message("*** future_lapply() ... DONE")
  + }
  + 
  + source("incl/end.R")
  + 
  + }
  Loading required package: future
  [12:36:22.797] plan(): Setting new future strategy stack:
  [12:36:22.798] List of future strategies:
  [12:36:22.798] 1. mirai_multisession:
  [12:36:22.798]    - args: function (expr, substitute = TRUE, envir = parent.frame(), ..., workers = availableCores())
  [12:36:22.798]    - tweaked: FALSE
  [12:36:22.798]    - call: future::plan(future.mirai::mirai_multisession)
  [12:36:22.816] plan(): plan_init() of 'mirai_multisession', 'mirai_cluster', 'mirai', 'multiprocess', 'future', 'function' ...
  [12:36:22.816] < mirai [$data] >
  [12:36:22.823] getGlobalsAndPackages() ...
  [12:36:22.823] Not searching for globals
  [12:36:22.824] - globals: [0] <none>
  [12:36:22.824] getGlobalsAndPackages() ... DONE
  [12:36:22.825] getGlobalsAndPackages() ...
  [12:36:22.825] 
  [12:36:22.825] - globals: [0] <none>
  [12:36:22.825] getGlobalsAndPackages() ... DONE
  [12:36:23.238] Packages needed by the future expression (n = 0): <none>
  [12:36:23.238] Packages needed by future strategies (n = 0): <none>
  [12:36:23.240] {
  [12:36:23.240]     {
  [12:36:23.240]         {
  [12:36:23.240]             ...future.startTime <- base::Sys.time()
  [12:36:23.240]             {
  [12:36:23.240]                 {
  [12:36:23.240]                   {
  [12:36:23.240]                     base::local({
  [12:36:23.240]                       has_future <- base::requireNamespace("future", 
  [12:36:23.240]                         quietly = TRUE)
  [12:36:23.240]                       if (has_future) {
  [12:36:23.240]                         ns <- base::getNamespace("future")
  [12:36:23.240]                         version <- ns[[".package"]][["version"]]
  [12:36:23.240]                         if (is.null(version)) 
  [12:36:23.240]                           version <- utils::packageVersion("future")
  [12:36:23.240]                       }
  [12:36:23.240]                       else {
  [12:36:23.240]                         version <- NULL
  [12:36:23.240]                       }
  [12:36:23.240]                       if (!has_future || version < "1.8.0") {
  [12:36:23.240]                         info <- base::c(r_version = base::gsub("R version ", 
  [12:36:23.240]                           "", base::R.version$version.string), 
  [12:36:23.240]                           platform = base::sprintf("%s (%s-bit)", 
  [12:36:23.240]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [12:36:23.240]                           os = base::paste(base::Sys.info()[base::c("sysname", 
  [12:36:23.240]                             "release", "version")], collapse = " "), 
  [12:36:23.240]                           hostname = base::Sys.info()[["nodename"]])
  [12:36:23.240]                         info <- base::sprintf("%s: %s", base::names(info), 
  [12:36:23.240]                           info)
  [12:36:23.240]                         info <- base::paste(info, collapse = "; ")
  [12:36:23.240]                         if (!has_future) {
  [12:36:23.240]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [12:36:23.240]                             info)
  [12:36:23.240]                         }
  [12:36:23.240]                         else {
  [12:36:23.240]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [12:36:23.240]                             info, version)
  [12:36:23.240]                         }
  [12:36:23.240]                         base::stop(msg)
  [12:36:23.240]                       }
  [12:36:23.240]                     })
  [12:36:23.240]                   }
  [12:36:23.240]                   ...future.strategy.old <- future::plan("list")
  [12:36:23.240]                   options(future.plan = NULL)
  [12:36:23.240]                   Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:23.240]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
  [12:36:23.240]                 }
  [12:36:23.240]                 ...future.workdir <- getwd()
  [12:36:23.240]             }
  [12:36:23.240]             ...future.oldOptions <- base::as.list(base::.Options)
  [12:36:23.240]             ...future.oldEnvVars <- base::Sys.getenv()
  [12:36:23.240]         }
  [12:36:23.240]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
  [12:36:23.240]             future.globals.maxSize = NULL, future.globals.method = NULL, 
  [12:36:23.240]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
  [12:36:23.240]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
  [12:36:23.240]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
  [12:36:23.240]             future.stdout.windows.reencode = NULL, width = 80L)
  [12:36:23.240]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
  [12:36:23.240]             base::names(...future.oldOptions))
  [12:36:23.240]     }
  [12:36:23.240]     if (FALSE) {
  [12:36:23.240]     }
  [12:36:23.240]     else {
  [12:36:23.240]         if (TRUE) {
  [12:36:23.240]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [12:36:23.240]                 open = "w")
  [12:36:23.240]         }
  [12:36:23.240]         else {
  [12:36:23.240]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [12:36:23.240]                 windows = "NUL", "/dev/null"), open = "w")
  [12:36:23.240]         }
  [12:36:23.240]         base::sink(...future.stdout, type = "output", split = FALSE)
  [12:36:23.240]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [12:36:23.240]             base::sink(type = "output", split = FALSE)
  [12:36:23.240]             base::close(...future.stdout)
  [12:36:23.240]         }, add = TRUE)
  [12:36:23.240]     }
  [12:36:23.240]     ...future.frame <- base::sys.nframe()
  [12:36:23.240]     ...future.conditions <- base::list()
  [12:36:23.240]     ...future.rng <- base::globalenv()$.Random.seed
  [12:36:23.240]     if (FALSE) {
  [12:36:23.240]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
  [12:36:23.240]             "...future.value", "...future.globalenv.names", ".Random.seed")
  [12:36:23.240]     }
  [12:36:23.240]     ...future.result <- base::tryCatch({
  [12:36:23.240]         base::withCallingHandlers({
  [12:36:23.240]             ...future.value <- base::withVisible(base::local(NA))
  [12:36:23.240]             future::FutureResult(value = ...future.value$value, 
  [12:36:23.240]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:23.240]                   ...future.rng), globalenv = if (FALSE) 
  [12:36:23.240]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
  [12:36:23.240]                     ...future.globalenv.names))
  [12:36:23.240]                 else NULL, started = ...future.startTime, version = "1.8")
  [12:36:23.240]         }, condition = base::local({
  [12:36:23.240]             c <- base::c
  [12:36:23.240]             inherits <- base::inherits
  [12:36:23.240]             invokeRestart <- base::invokeRestart
  [12:36:23.240]             length <- base::length
  [12:36:23.240]             list <- base::list
  [12:36:23.240]             seq.int <- base::seq.int
  [12:36:23.240]             signalCondition <- base::signalCondition
  [12:36:23.240]             sys.calls <- base::sys.calls
  [12:36:23.240]             `[[` <- base::`[[`
  [12:36:23.240]             `+` <- base::`+`
  [12:36:23.240]             `<<-` <- base::`<<-`
  [12:36:23.240]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [12:36:23.240]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [12:36:23.240]                   3L)]
  [12:36:23.240]             }
  [12:36:23.240]             function(cond) {
  [12:36:23.240]                 is_error <- inherits(cond, "error")
  [12:36:23.240]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
  [12:36:23.240]                   NULL)
  [12:36:23.240]                 if (is_error) {
  [12:36:23.240]                   sessionInformation <- function() {
  [12:36:23.240]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
  [12:36:23.240]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
  [12:36:23.240]                       search = base::search(), system = base::Sys.info())
  [12:36:23.240]                   }
  [12:36:23.240]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:23.240]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [12:36:23.240]                     cond$call), session = sessionInformation(), 
  [12:36:23.240]                     timestamp = base::Sys.time(), signaled = 0L)
  [12:36:23.240]                   signalCondition(cond)
  [12:36:23.240]                 }
  [12:36:23.240]                 else if (!ignore && TRUE && inherits(cond, "condition")) {
  [12:36:23.240]                   signal <- FALSE && inherits(cond, character(0))
  [12:36:23.240]                   ...future.conditions[[length(...future.conditions) + 
  [12:36:23.240]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [12:36:23.240]                   if (FALSE && !signal) {
  [12:36:23.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:23.240]                     {
  [12:36:23.240]                       inherits <- base::inherits
  [12:36:23.240]                       invokeRestart <- base::invokeRestart
  [12:36:23.240]                       is.null <- base::is.null
  [12:36:23.240]                       muffled <- FALSE
  [12:36:23.240]                       if (inherits(cond, "message")) {
  [12:36:23.240]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:23.240]                         if (muffled) 
  [12:36:23.240]                           invokeRestart("muffleMessage")
  [12:36:23.240]                       }
  [12:36:23.240]                       else if (inherits(cond, "warning")) {
  [12:36:23.240]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:23.240]                         if (muffled) 
  [12:36:23.240]                           invokeRestart("muffleWarning")
  [12:36:23.240]                       }
  [12:36:23.240]                       else if (inherits(cond, "condition")) {
  [12:36:23.240]                         if (!is.null(pattern)) {
  [12:36:23.240]                           computeRestarts <- base::computeRestarts
  [12:36:23.240]                           grepl <- base::grepl
  [12:36:23.240]                           restarts <- computeRestarts(cond)
  [12:36:23.240]                           for (restart in restarts) {
  [12:36:23.240]                             name <- restart$name
  [12:36:23.240]                             if (is.null(name)) 
  [12:36:23.240]                               next
  [12:36:23.240]                             if (!grepl(pattern, name)) 
  [12:36:23.240]                               next
  [12:36:23.240]                             invokeRestart(restart)
  [12:36:23.240]                             muffled <- TRUE
  [12:36:23.240]                             break
  [12:36:23.240]                           }
  [12:36:23.240]                         }
  [12:36:23.240]                       }
  [12:36:23.240]                       invisible(muffled)
  [12:36:23.240]                     }
  [12:36:23.240]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:23.240]                   }
  [12:36:23.240]                 }
  [12:36:23.240]                 else {
  [12:36:23.240]                   if (TRUE) {
  [12:36:23.240]                     muffleCondition <- function (cond, pattern = "^muffle") 
  [12:36:23.240]                     {
  [12:36:23.240]                       inherits <- base::inherits
  [12:36:23.240]                       invokeRestart <- base::invokeRestart
  [12:36:23.240]                       is.null <- base::is.null
  [12:36:23.240]                       muffled <- FALSE
  [12:36:23.240]                       if (inherits(cond, "message")) {
  [12:36:23.240]                         muffled <- grepl(pattern, "muffleMessage")
  [12:36:23.240]                         if (muffled) 
  [12:36:23.240]                           invokeRestart("muffleMessage")
  [12:36:23.240]                       }
  [12:36:23.240]                       else if (inherits(cond, "warning")) {
  [12:36:23.240]                         muffled <- grepl(pattern, "muffleWarning")
  [12:36:23.240]                         if (muffled) 
  [12:36:23.240]                           invokeRestart("muffleWarning")
  [12:36:23.240]                       }
  [12:36:23.240]                       else if (inherits(cond, "condition")) {
  [12:36:23.240]                         if (!is.null(pattern)) {
  [12:36:23.240]                           computeRestarts <- base::computeRestarts
  [12:36:23.240]                           grepl <- base::grepl
  [12:36:23.240]                           restarts <- computeRestarts(cond)
  [12:36:23.240]                           for (restart in restarts) {
  [12:36:23.240]                             name <- restart$name
  [12:36:23.240]                             if (is.null(name)) 
  [12:36:23.240]                               next
  [12:36:23.240]                             if (!grepl(pattern, name)) 
  [12:36:23.240]                               next
  [12:36:23.240]                             invokeRestart(restart)
  [12:36:23.240]                             muffled <- TRUE
  [12:36:23.240]                             break
  [12:36:23.240]                           }
  [12:36:23.240]                         }
  [12:36:23.240]                       }
  [12:36:23.240]                       invisible(muffled)
  [12:36:23.240]                     }
  [12:36:23.240]                     muffleCondition(cond, pattern = "^muffle")
  [12:36:23.240]                   }
  [12:36:23.240]                 }
  [12:36:23.240]             }
  [12:36:23.240]         }))
  [12:36:23.240]     }, error = function(ex) {
  [12:36:23.240]         base::structure(base::list(value = NULL, visible = NULL, 
  [12:36:23.240]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [12:36:23.240]                 ...future.rng), started = ...future.startTime, 
  [12:36:23.240]             finished = Sys.time(), session_uuid = NA_character_, 
  [12:36:23.240]             version = "1.8"), class = "FutureResult")
  [12:36:23.240]     }, finally = {
  [12:36:23.240]         if (!identical(...future.workdir, getwd())) 
  [12:36:23.240]             setwd(...future.workdir)
  [12:36:23.240]         {
  [12:36:23.240]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
  [12:36:23.240]                 ...future.oldOptions$nwarnings <- NULL
  [12:36:23.240]             }
  [12:36:23.240]             base::options(...future.oldOptions)
  [12:36:23.240]             if (.Platform$OS.type == "windows") {
  [12:36:23.240]                 old_names <- names(...future.oldEnvVars)
  [12:36:23.240]                 envs <- base::Sys.getenv()
  [12:36:23.240]                 names <- names(envs)
  [12:36:23.240]                 common <- intersect(names, old_names)
  [12:36:23.240]                 added <- setdiff(names, old_names)
  [12:36:23.240]                 removed <- setdiff(old_names, names)
  [12:36:23.240]                 changed <- common[...future.oldEnvVars[common] != 
  [12:36:23.240]                   envs[common]]
  [12:36:23.240]                 NAMES <- toupper(changed)
  [12:36:23.240]                 args <- list()
  [12:36:23.240]                 for (kk in seq_along(NAMES)) {
  [12:36:23.240]                   name <- changed[[kk]]
  [12:36:23.240]                   NAME <- NAMES[[kk]]
  [12:36:23.240]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:23.240]                     next
  [12:36:23.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:23.240]                 }
  [12:36:23.240]                 NAMES <- toupper(added)
  [12:36:23.240]                 for (kk in seq_along(NAMES)) {
  [12:36:23.240]                   name <- added[[kk]]
  [12:36:23.240]                   NAME <- NAMES[[kk]]
  [12:36:23.240]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:23.240]                     next
  [12:36:23.240]                   args[[name]] <- ""
  [12:36:23.240]                 }
  [12:36:23.240]                 NAMES <- toupper(removed)
  [12:36:23.240]                 for (kk in seq_along(NAMES)) {
  [12:36:23.240]                   name <- removed[[kk]]
  [12:36:23.240]                   NAME <- NAMES[[kk]]
  [12:36:23.240]                   if (name != NAME && is.element(NAME, old_names)) 
  [12:36:23.240]                     next
  [12:36:23.240]                   args[[name]] <- ...future.oldEnvVars[[name]]
  [12:36:23.240]                 }
  [12:36:23.240]                 if (length(args) > 0) 
  [12:36:23.240]                   base::do.call(base::Sys.setenv, args = args)
  [12:36:23.240]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
  [12:36:23.240]             }
  [12:36:23.240]             else {
  [12:36:23.240]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
  [12:36:23.240]             }
  [12:36:23.240]             {
  [12:36:23.240]                 if (base::length(...future.futureOptionsAdded) > 
  [12:36:23.240]                   0L) {
  [12:36:23.240]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
  [12:36:23.240]                   base::names(opts) <- ...future.futureOptionsAdded
  [12:36:23.240]                   base::options(opts)
  [12:36:23.240]                 }
  [12:36:23.240]                 {
  [12:36:23.240]                   NULL
  [12:36:23.240]                   options(future.plan = NULL)
  [12:36:23.240]                   if (is.na(NA_character_)) 
  [12:36:23.240]                     Sys.unsetenv("R_FUTURE_PLAN")
  [12:36:23.240]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
  [12:36:23.240]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
  [12:36:23.240]                     .init = FALSE)
  [12:36:23.240]                 }
  [12:36:23.240]             }
  [12:36:23.240]         }
  [12:36:23.240]     })
  [12:36:23.240]     if (TRUE) {
  [12:36:23.240]         base::sink(type = "output", split = FALSE)
  [12:36:23.240]         if (TRUE) {
  [12:36:23.240]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [12:36:23.240]         }
  [12:36:23.240]         else {
  [12:36:23.240]             ...future.result["stdout"] <- base::list(NULL)
  [12:36:23.240]         }
  [12:36:23.240]         base::close(...future.stdout)
  [12:36:23.240]         ...future.stdout <- NULL
  [12:36:23.240]     }
  [12:36:23.240]     ...future.result$conditions <- ...future.conditions
  [12:36:23.240]     ...future.result$finished <- base::Sys.time()
  [12:36:23.240]     ...future.result
  [12:36:23.240] }
  Error in request(.context(envir[["sock"]]), data = data, send_mode = 3L,  : 
    R_ExternalPtrTag: argument of type NILSXP is not an external pointer
  Calls: source ... run.MiraiFuture -> do.call -> <Anonymous> -> request
  Execution halted
* checking PDF version of manual ... [21s] OK
* checking HTML version of manual ... [1s] OK
* DONE
Status: 2 ERRORs