Running '000.sessionDetails.R' [8s/8s]
  Running 'ClusterRegistry.R' [3s/55s]
  Running 'Future-class.R' [2s/19s]
  Running 'FutureError.R' [1s/1s]
  Running 'FutureGlobals.R' [1s/1s]
  Running 'FutureRegistry.R' [1s/1s]
  Running 'as.cluster.R' [1s/18s]
  Running 'availableCores.R' [1s/1s]
  Running 'availableWorkers.R' [1s/1s]
  Running 'backtrace.R' [1s/2s]
  Running 'cluster-missing-future-pkg.R' [1s/3s]
  Running 'cluster.R' [7s/126s]
  Running 'constant.R' [1s/1s]
  Running 'demo.R' [10s/30s]
  Running 'dotdotdot.R' [2s/20s]
  Running 'early-signaling.R' [2s/41s]
  Running 'future,labels.R' [1s/1s]
  Running 'future.R' [1s/1s]
  Running 'futureAssign.R' [2s/21s]
  Running 'futureAssign_OP.R' [3s/22s]
  Running 'futureAssign_OP_with_environment.R' [1s/1s]
  Running 'futureAssign_OP_with_listenv.R' [1s/1s]
  Running 'futureCall.R' [5s/31s]
  Running 'futureOf.R' [1s/1s]
  Running 'futureOf_with_environment.R' [1s/1s]
  Running 'futureOf_with_listenv.R' [1s/1s]
  Running 'futures.R' [20s/151s]
  Running 'globals,NSE.R' [1s/1s]
  Running 'globals,formulas.R' [4s/23s]
  Running 'globals,manual.R' [2s/3s]
  Running 'globals,resolve.R' [2s/18s]
  Running 'globals,subassignment.R' [3s/23s]
  Running 'globals,toolarge.R' [1s/18s]
  Running 'globals,tricky.R' [8s/27s]
  Running 'globals,tricky_recursive.R' [1s/1s]
  Running 'globalsOf,tweaks.R' [1s/1s]
  Running 'immediateCondition.R' [1s/2s]
  Running 'invalid-owner.R' [2s/20s]
  Running 'makeClusterPSOCK.R' [1s/10s]
  Running 'mandelbrot.R' [1s/1s]
  Running 'mpi.R' [1s/1s]
  Running 'multicore,multithreading.R' [1s/1s]
  Running 'multicore.R' [1s/1s]
  Running 'multiprocess.R' [2s/2s]
  Running 'multisession.R' [5s/56s]
  Running 'nbrOfWorkers.R' [3s/55s]
  Running 'nested_futures,mc.cores.R' [6s/125s]
  Running 'nested_futures.R' [1s/1s]
  Running 'non-exportable,connections.R' [1s/18s]
  Running 'objectSize.R' [1s/1s]
  Running 'plan.R' [6s/16s]
  Running 'relaying.R' [1s/2s]
  Running 'remote.R' [1s/18s]
  Running 'requestCore.R' [1s/3s]
  Running 'requestNode.R' [2s/32s]
  Running 'reserved-keyword-functions.R' [1s/1s]
  Running 'resolve.R' [2s/4s]
  Running 'resolved-non-blocking-test.R' [3s/71s]
  Running 'rng.R' [12s/34s]
  Running 'sequential.R' [1s/1s]
  Running 'sessionDetails.R' [1s/1s]
  Running 'startup.R' [2s/37s]
  Running 'stdout.R' [2s/21s]
  Running 'transparent.R' [1s/1s]
  Running 'tweak.R' [1s/1s]
  Running 'utils.R' [8s/9s]
  Running 'uuid.R' [1s/1s]
  Running 'whichIndex.R' [1s/1s]
Running the tests in 'tests/multicore,multithreading.R' failed.
Complete output:
  > source("incl/start.R")
  [23:39:36.656] plan(): Setting new future strategy stack:
  [23:39:36.658] List of future strategies:
  [23:39:36.658] 1. sequential:
  [23:39:36.658]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [23:39:36.658]    - tweaked: FALSE
  [23:39:36.658]    - call: future::plan("sequential")
  [23:39:36.660] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > plan(multicore)
  [23:39:36.705] plan(): Setting new future strategy stack:
  [23:39:36.706] List of future strategies:
  [23:39:36.706] 1. multicore:
  [23:39:36.706]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [23:39:36.706]    - tweaked: FALSE
  [23:39:36.706]    - call: plan(multicore)
  [23:39:36.765] plan(): nbrOfWorkers() = 2
  > 
  > message("*** multicore() and multi-threading ...")
  *** multicore() and multi-threading ...
  > 
  > message("supportsMulticore(): ", sQuote(supportsMulticore()))
  supportsMulticore(): 'TRUE'
  > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
  availableCores('multicore'): '2'
  > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
  [23:39:36.794] supports_omp_threads() = TRUE
  supports_omp_threads(): 'TRUE'
  > 
  > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
  +   for (enable in c(TRUE, FALSE)) {
  +     options(future.fork.multithreading.enable = enable)
  + 
  +     message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
  + 
  +     f <- future(RhpcBLASctl::omp_get_max_threads())
  +     nthreads <- value(f)
  +     cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
  + 
  +     ## Assert that single-threading was set?
  +     if (enable) {
  +       stopifnot(enable && nthreads > 1L)
  +     } else {
  +       stopifnot(!enable && nthreads == 1L)
  +     }
  +       
  +     message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
  +   } ## for (enable ...)
  + } ## if (requireNamespace("RhpcBLASctl", ...)) {
  [23:39:36.796] supports_omp_threads() = TRUE
  'future.fork.multithreading.enable' = TRUE ...
  [23:39:36.861] getGlobalsAndPackages() ...
  [23:39:36.862] Searching for globals...
  [23:39:36.879] - globals found: [1] '::'
  [23:39:36.879] Searching for globals ... DONE
  [23:39:36.880] Resolving globals: FALSE
  [23:39:36.881] 
  [23:39:36.882] 
  [23:39:36.882] getGlobalsAndPackages() ... DONE
  [23:39:36.887] Packages needed by the future expression (n = 0): <none>
  [23:39:36.887] Packages needed by future strategies (n = 0): <none>
  [23:39:36.894] {
  [23:39:36.894]     {
  [23:39:36.894]         ...future.startTime <- base::Sys.time()
  [23:39:36.894]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:39:36.894]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:39:36.894]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:39:36.894]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:39:36.894]             future.resolve.recursive = NULL, width = 80L)
  [23:39:36.894]         {
  [23:39:36.894]             {
  [23:39:36.894]                 {
  [23:39:36.894]                   has_future <- base::requireNamespace("future", 
  [23:39:36.894]                     quietly = TRUE)
  [23:39:36.894]                   version <- if (has_future) 
  [23:39:36.894]                     utils::packageVersion("future")
  [23:39:36.894]                   else NULL
  [23:39:36.894]                   if (!has_future || version < "1.8.0") {
  [23:39:36.894]                     info <- base::c(r_version = base::gsub("R version ", 
  [23:39:36.894]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:39:36.894]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:39:36.894]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:39:36.894]                         "release", "version")], collapse = " "), 
  [23:39:36.894]                       hostname = base::Sys.info()[["nodename"]])
  [23:39:36.894]                     info <- base::sprintf("%s: %s", base::names(info), 
  [23:39:36.894]                       info)
  [23:39:36.894]                     info <- base::paste(info, collapse = "; ")
  [23:39:36.894]                     if (!has_future) {
  [23:39:36.894]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:39:36.894]                         info)
  [23:39:36.894]                     }
  [23:39:36.894]                     else {
  [23:39:36.894]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:39:36.894]                         info, version)
  [23:39:36.894]                     }
  [23:39:36.894]                     base::stop(msg)
  [23:39:36.894]                   }
  [23:39:36.894]                 }
  [23:39:36.894]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [23:39:36.894]                 base::options(mc.cores = 1L)
  [23:39:36.894]             }
  [23:39:36.894]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:39:36.894]         }
  [23:39:36.894]     }
  [23:39:36.894]     if (base::is.na(TRUE)) {
  [23:39:36.894]     }
  [23:39:36.894]     else {
  [23:39:36.894]         if (TRUE) {
  [23:39:36.894]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:39:36.894]                 open = "w")
  [23:39:36.894]         }
  [23:39:36.894]         else {
  [23:39:36.894]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:39:36.894]                 windows = "NUL", "/dev/null"), open = "w")
  [23:39:36.894]         }
  [23:39:36.894]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:39:36.894]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:39:36.894]             base::sink(type = "output", split = FALSE)
  [23:39:36.894]             base::close(...future.stdout)
  [23:39:36.894]         }, add = TRUE)
  [23:39:36.894]     }
  [23:39:36.894]     ...future.frame <- base::sys.nframe()
  [23:39:36.894]     ...future.conditions <- base::list()
  [23:39:36.894]     ...future.rng <- base::globalenv()$.Random.seed
  [23:39:36.894]     ...future.result <- base::tryCatch({
  [23:39:36.894]         base::withCallingHandlers({
  [23:39:36.894]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [23:39:36.894]             future::FutureResult(value = ...future.value$value, 
  [23:39:36.894]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:39:36.894]                   ...future.rng), started = ...future.startTime, 
  [23:39:36.894]                 version = "1.8")
  [23:39:36.894]         }, condition = base::local({
  [23:39:36.894]             c <- base::c
  [23:39:36.894]             inherits <- base::inherits
  [23:39:36.894]             invokeRestart <- base::invokeRestart
  [23:39:36.894]             length <- base::length
  [23:39:36.894]             list <- base::list
  [23:39:36.894]             seq.int <- base::seq.int
  [23:39:36.894]             signalCondition <- base::signalCondition
  [23:39:36.894]             sys.calls <- base::sys.calls
  [23:39:36.894]             Sys.time <- base::Sys.time
  [23:39:36.894]             `[[` <- base::`[[`
  [23:39:36.894]             `+` <- base::`+`
  [23:39:36.894]             `<<-` <- base::`<<-`
  [23:39:36.894]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:39:36.894]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [23:39:36.894]                   3L)]
  [23:39:36.894]             }
  [23:39:36.894]             function(cond) {
  [23:39:36.894]                 if (inherits(cond, "error")) {
  [23:39:36.894]                   ...future.conditions[[length(...future.conditions) + 
  [23:39:36.894]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:39:36.894]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:39:36.894]                   signalCondition(cond)
  [23:39:36.894]                 }
  [23:39:36.894]                 else if (inherits(cond, "condition")) {
  [23:39:36.894]                   signal <- FALSE && inherits(cond, character(0))
  [23:39:36.894]                   ...future.conditions[[length(...future.conditions) + 
  [23:39:36.894]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:39:36.894]                   if (!signal) {
  [23:39:36.894]                     muffleCondition <- function (cond) 
  [23:39:36.894]                     {
  [23:39:36.894]                       inherits <- base::inherits
  [23:39:36.894]                       invokeRestart <- base::invokeRestart
  [23:39:36.894]                       muffled <- FALSE
  [23:39:36.894]                       if (inherits(cond, "message")) {
  [23:39:36.894]                         invokeRestart("muffleMessage")
  [23:39:36.894]                         muffled <- TRUE
  [23:39:36.894]                       }
  [23:39:36.894]                       else if (inherits(cond, "warning")) {
  [23:39:36.894]                         invokeRestart("muffleWarning")
  [23:39:36.894]                         muffled <- TRUE
  [23:39:36.894]                       }
  [23:39:36.894]                       else if (inherits(cond, "condition")) {
  [23:39:36.894]                         computeRestarts <- base::computeRestarts
  [23:39:36.894]                         grepl <- base::grepl
  [23:39:36.894]                         is.null <- base::is.null
  [23:39:36.894]                         restarts <- computeRestarts(cond)
  [23:39:36.894]                         for (restart in restarts) {
  [23:39:36.894]                           name <- restart$name
  [23:39:36.894]                           if (is.null(name)) 
  [23:39:36.894]                             next
  [23:39:36.894]                           if (!grepl("^muffle", name)) 
  [23:39:36.894]                             next
  [23:39:36.894]                           invokeRestart(restart)
  [23:39:36.894]                           muffled <- TRUE
  [23:39:36.894]                           break
  [23:39:36.894]                         }
  [23:39:36.894]                       }
  [23:39:36.894]                       invisible(muffled)
  [23:39:36.894]                     }
  [23:39:36.894]                     muffleCondition(cond)
  [23:39:36.894]                   }
  [23:39:36.894]                 }
  [23:39:36.894]             }
  [23:39:36.894]         }))
  [23:39:36.894]     }, error = function(ex) {
  [23:39:36.894]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:39:36.894]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:39:36.894]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:39:36.894]     }, finally = {
  [23:39:36.894]         {
  [23:39:36.894]             {
  [23:39:36.894]                 base::options(mc.cores = ...future.mc.cores.old)
  [23:39:36.894]             }
  [23:39:36.894]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:39:36.894]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:39:36.894]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [23:39:36.894]                 earlySignal = FALSE, label = NULL, ...) 
  [23:39:36.894]             {
  [23:39:36.894]                 if (substitute) 
  [23:39:36.894]                   expr <- substitute(expr)
  [23:39:36.894]                 if (is.function(workers)) 
  [23:39:36.894]                   workers <- workers()
  [23:39:36.894]                 workers <- as.integer(workers)
  [23:39:36.894]                 stop_if_not(is.finite(workers), workers >= 1L)
  [23:39:36.894]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [23:39:36.894]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [23:39:36.894]                     lazy = lazy, seed = seed, globals = globals, 
  [23:39:36.894]                     local = TRUE, label = label, ...))
  [23:39:36.894]                 }
  [23:39:36.894]                 oopts <- options(mc.cores = workers)
  [23:39:36.894]                 on.exit(options(oopts))
  [23:39:36.894]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [23:39:36.894]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:39:36.894]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [23:39:36.894]                   label = label, ...)
  [23:39:36.894]                 if (!future$lazy) 
  [23:39:36.894]                   future <- run(future)
  [23:39:36.894]                 invisible(future)
  [23:39:36.894]             }), .cleanup = FALSE, .init = FALSE)
  [23:39:36.894]         }
  [23:39:36.894]         base::options(...future.oldOptions)
  [23:39:36.894]     })
  [23:39:36.894]     Sys.time
  [23:39:36.894]     if (base::is.na(TRUE)) {
  [23:39:36.894]     }
  [23:39:36.894]     else {
  [23:39:36.894]         base::sink(type = "output", split = FALSE)
  [23:39:36.894]         if (TRUE) {
  [23:39:36.894]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:39:36.894]         }
  [23:39:36.894]         else {
  [23:39:36.894]             ...future.result["stdout"] <- base::list(NULL)
  [23:39:36.894]         }
  [23:39:36.894]         base::close(...future.stdout)
  [23:39:36.894]         ...future.stdout <- NULL
  [23:39:36.894]     }
  [23:39:36.894]     ...future.result$conditions <- ...future.conditions
  [23:39:36.894]     ...future.result
  [23:39:36.894] }
  [23:39:36.922] requestCore(): workers = 2
  [23:39:36.927] MulticoreFuture started
  [23:39:36.939] plan(): Setting new future strategy stack:
  [23:39:36.940] List of future strategies:
  [23:39:36.940] 1. sequential:
  [23:39:36.940]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [23:39:36.940]    - tweaked: FALSE
  [23:39:36.940]    - call: NULL
  [23:39:36.942] plan(): nbrOfWorkers() = 1
  [23:39:36.945] plan(): Setting new future strategy stack:
  [23:39:36.946] List of future strategies:
  [23:39:36.946] 1. multicore:
  [23:39:36.946]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [23:39:36.946]    - tweaked: FALSE
  [23:39:36.946]    - call: plan(multicore)
  [23:39:36.948] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 3
  'future.fork.multithreading.enable' = TRUE ... DONE
  'future.fork.multithreading.enable' = FALSE ...
  [23:39:36.979] getGlobalsAndPackages() ...
  [23:39:36.980] Searching for globals...
  [23:39:36.982] - globals found: [1] '::'
  [23:39:36.982] Searching for globals ... DONE
  [23:39:36.983] Resolving globals: FALSE
  [23:39:36.983] 
  [23:39:36.984] 
  [23:39:36.984] getGlobalsAndPackages() ... DONE
  [23:39:36.985] - Evaluate future in single-threaded mode ...
  [23:39:36.985] supports_omp_threads() = TRUE
  [23:39:36.986]   - Force single-threaded processing for OpenMP
  [23:39:36.986] - Evaluate future in single-threaded mode ... DONE
  [23:39:36.989] Packages needed by the future expression (n = 0): <none>
  [23:39:36.989] Packages needed by future strategies (n = 0): <none>
  [23:39:37.004] {
  [23:39:37.004]     {
  [23:39:37.004]         ...future.startTime <- base::Sys.time()
  [23:39:37.004]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:39:37.004]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:39:37.004]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:39:37.004]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:39:37.004]             future.resolve.recursive = NULL, width = 80L)
  [23:39:37.004]         {
  [23:39:37.004]             {
  [23:39:37.004]                 {
  [23:39:37.004]                   has_future <- base::requireNamespace("future", 
  [23:39:37.004]                     quietly = TRUE)
  [23:39:37.004]                   version <- if (has_future) 
  [23:39:37.004]                     utils::packageVersion("future")
  [23:39:37.004]                   else NULL
  [23:39:37.004]                   if (!has_future || version < "1.8.0") {
  [23:39:37.004]                     info <- base::c(r_version = base::gsub("R version ", 
  [23:39:37.004]                       "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:39:37.004]                       base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:39:37.004]                       os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:39:37.004]                         "release", "version")], collapse = " "), 
  [23:39:37.004]                       hostname = base::Sys.info()[["nodename"]])
  [23:39:37.004]                     info <- base::sprintf("%s: %s", base::names(info), 
  [23:39:37.004]                       info)
  [23:39:37.004]                     info <- base::paste(info, collapse = "; ")
  [23:39:37.004]                     if (!has_future) {
  [23:39:37.004]                       msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:39:37.004]                         info)
  [23:39:37.004]                     }
  [23:39:37.004]                     else {
  [23:39:37.004]                       msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:39:37.004]                         info, version)
  [23:39:37.004]                     }
  [23:39:37.004]                     base::stop(msg)
  [23:39:37.004]                   }
  [23:39:37.004]                 }
  [23:39:37.004]                 ...future.mc.cores.old <- base::getOption("mc.cores")
  [23:39:37.004]                 base::options(mc.cores = 1L)
  [23:39:37.004]             }
  [23:39:37.004]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:39:37.004]         }
  [23:39:37.004]     }
  [23:39:37.004]     if (base::is.na(TRUE)) {
  [23:39:37.004]     }
  [23:39:37.004]     else {
  [23:39:37.004]         if (TRUE) {
  [23:39:37.004]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:39:37.004]                 open = "w")
  [23:39:37.004]         }
  [23:39:37.004]         else {
  [23:39:37.004]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:39:37.004]                 windows = "NUL", "/dev/null"), open = "w")
  [23:39:37.004]         }
  [23:39:37.004]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:39:37.004]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:39:37.004]             base::sink(type = "output", split = FALSE)
  [23:39:37.004]             base::close(...future.stdout)
  [23:39:37.004]         }, add = TRUE)
  [23:39:37.004]     }
  [23:39:37.004]     ...future.frame <- base::sys.nframe()
  [23:39:37.004]     ...future.conditions <- base::list()
  [23:39:37.004]     ...future.rng <- base::globalenv()$.Random.seed
  [23:39:37.004]     ...future.result <- base::tryCatch({
  [23:39:37.004]         base::withCallingHandlers({
  [23:39:37.004]             ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
  [23:39:37.004]             future::FutureResult(value = ...future.value$value, 
  [23:39:37.004]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:39:37.004]                   ...future.rng), started = ...future.startTime, 
  [23:39:37.004]                 version = "1.8")
  [23:39:37.004]         }, condition = base::local({
  [23:39:37.004]             c <- base::c
  [23:39:37.004]             inherits <- base::inherits
  [23:39:37.004]             invokeRestart <- base::invokeRestart
  [23:39:37.004]             length <- base::length
  [23:39:37.004]             list <- base::list
  [23:39:37.004]             seq.int <- base::seq.int
  [23:39:37.004]             signalCondition <- base::signalCondition
  [23:39:37.004]             sys.calls <- base::sys.calls
  [23:39:37.004]             Sys.time <- base::Sys.time
  [23:39:37.004]             `[[` <- base::`[[`
  [23:39:37.004]             `+` <- base::`+`
  [23:39:37.004]             `<<-` <- base::`<<-`
  [23:39:37.004]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:39:37.004]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [23:39:37.004]                   3L)]
  [23:39:37.004]             }
  [23:39:37.004]             function(cond) {
  [23:39:37.004]                 if (inherits(cond, "error")) {
  [23:39:37.004]                   ...future.conditions[[length(...future.conditions) + 
  [23:39:37.004]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:39:37.004]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:39:37.004]                   signalCondition(cond)
  [23:39:37.004]                 }
  [23:39:37.004]                 else if (inherits(cond, "condition")) {
  [23:39:37.004]                   signal <- FALSE && inherits(cond, character(0))
  [23:39:37.004]                   ...future.conditions[[length(...future.conditions) + 
  [23:39:37.004]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:39:37.004]                   if (!signal) {
  [23:39:37.004]                     muffleCondition <- function (cond) 
  [23:39:37.004]                     {
  [23:39:37.004]                       inherits <- base::inherits
  [23:39:37.004]                       invokeRestart <- base::invokeRestart
  [23:39:37.004]                       muffled <- FALSE
  [23:39:37.004]                       if (inherits(cond, "message")) {
  [23:39:37.004]                         invokeRestart("muffleMessage")
  [23:39:37.004]                         muffled <- TRUE
  [23:39:37.004]                       }
  [23:39:37.004]                       else if (inherits(cond, "warning")) {
  [23:39:37.004]                         invokeRestart("muffleWarning")
  [23:39:37.004]                         muffled <- TRUE
  [23:39:37.004]                       }
  [23:39:37.004]                       else if (inherits(cond, "condition")) {
  [23:39:37.004]                         computeRestarts <- base::computeRestarts
  [23:39:37.004]                         grepl <- base::grepl
  [23:39:37.004]                         is.null <- base::is.null
  [23:39:37.004]                         restarts <- computeRestarts(cond)
  [23:39:37.004]                         for (restart in restarts) {
  [23:39:37.004]                           name <- restart$name
  [23:39:37.004]                           if (is.null(name)) 
  [23:39:37.004]                             next
  [23:39:37.004]                           if (!grepl("^muffle", name)) 
  [23:39:37.004]                             next
  [23:39:37.004]                           invokeRestart(restart)
  [23:39:37.004]                           muffled <- TRUE
  [23:39:37.004]                           break
  [23:39:37.004]                         }
  [23:39:37.004]                       }
  [23:39:37.004]                       invisible(muffled)
  [23:39:37.004]                     }
  [23:39:37.004]                     muffleCondition(cond)
  [23:39:37.004]                   }
  [23:39:37.004]                 }
  [23:39:37.004]             }
  [23:39:37.004]         }))
  [23:39:37.004]     }, error = function(ex) {
  [23:39:37.004]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:39:37.004]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:39:37.004]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:39:37.004]     }, finally = {
  [23:39:37.004]         {
  [23:39:37.004]             {
  [23:39:37.004]                 base::options(mc.cores = ...future.mc.cores.old)
  [23:39:37.004]             }
  [23:39:37.004]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:39:37.004]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:39:37.004]                 globals = TRUE, workers = availableCores(constraints = "multicore"), 
  [23:39:37.004]                 earlySignal = FALSE, label = NULL, ...) 
  [23:39:37.004]             {
  [23:39:37.004]                 if (substitute) 
  [23:39:37.004]                   expr <- substitute(expr)
  [23:39:37.004]                 if (is.function(workers)) 
  [23:39:37.004]                   workers <- workers()
  [23:39:37.004]                 workers <- as.integer(workers)
  [23:39:37.004]                 stop_if_not(is.finite(workers), workers >= 1L)
  [23:39:37.004]                 if (workers == 1L || !supportsMulticore(warn = TRUE)) {
  [23:39:37.004]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [23:39:37.004]                     lazy = lazy, seed = seed, globals = globals, 
  [23:39:37.004]                     local = TRUE, label = label, ...))
  [23:39:37.004]                 }
  [23:39:37.004]                 oopts <- options(mc.cores = workers)
  [23:39:37.004]                 on.exit(options(oopts))
  [23:39:37.004]                 future <- MulticoreFuture(expr = expr, envir = envir, 
  [23:39:37.004]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:39:37.004]                   globals = globals, workers = workers, earlySignal = earlySignal, 
  [23:39:37.004]                   label = label, ...)
  [23:39:37.004]                 if (!future$lazy) 
  [23:39:37.004]                   future <- run(future)
  [23:39:37.004]                 invisible(future)
  [23:39:37.004]             }), .cleanup = FALSE, .init = FALSE)
  [23:39:37.004]         }
  [23:39:37.004]         base::options(...future.oldOptions)
  [23:39:37.004]     })
  [23:39:37.004]     Sys.time
  [23:39:37.004]     if (base::is.na(TRUE)) {
  [23:39:37.004]     }
  [23:39:37.004]     else {
  [23:39:37.004]         base::sink(type = "output", split = FALSE)
  [23:39:37.004]         if (TRUE) {
  [23:39:37.004]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:39:37.004]         }
  [23:39:37.004]         else {
  [23:39:37.004]             ...future.result["stdout"] <- base::list(NULL)
  [23:39:37.004]         }
  [23:39:37.004]         base::close(...future.stdout)
  [23:39:37.004]         ...future.stdout <- NULL
  [23:39:37.004]     }
  [23:39:37.004]     ...future.result$conditions <- ...future.conditions
  [23:39:37.004]     ...future.result
  [23:39:37.004] }
  [23:39:37.019] requestCore(): workers = 2
  [23:39:37.023] MulticoreFuture started
  [23:39:37.036] plan(): Setting new future strategy stack:
  [23:39:37.037] List of future strategies:
  [23:39:37.037] 1. sequential:
  [23:39:37.037]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [23:39:37.037]    - tweaked: FALSE
  [23:39:37.037]    - call: NULL
  [23:39:37.055] plan(): nbrOfWorkers() = 1
  [23:39:37.059] plan(): Setting new future strategy stack:
  [23:39:37.059] List of future strategies:
  [23:39:37.059] 1. multicore:
  [23:39:37.059]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [23:39:37.059]    - tweaked: FALSE
  [23:39:37.059]    - call: plan(multicore)
  [23:39:37.073] plan(): nbrOfWorkers() = 2
  Number of OpenMP threads in 'MulticoreFuture' future: 3
  Error: !enable && nthreads == 1L is not TRUE
  Execution halted
Running the tests in 'tests/nbrOfWorkers.R' failed.
Complete output:
  > source("incl/start.R")
  [23:40:38.027] plan(): Setting new future strategy stack:
  [23:40:38.028] List of future strategies:
  [23:40:38.028] 1. sequential:
  [23:40:38.028]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [23:40:38.028]    - tweaked: FALSE
  [23:40:38.028]    - call: future::plan("sequential")
  [23:40:38.030] plan(): nbrOfWorkers() = 1
  > 
  > message("*** nbrOfWorkers() ...")
  *** nbrOfWorkers() ...
  > 
  > strategies <- c("sequential", "transparent")
  > for (strategy in strategies) {
  +   message("Type of future: ", strategy)
  + 
  +   evaluator <- get(strategy, mode = "function")
  +   n <- nbrOfWorkers(evaluator)
  +   message(sprintf("nbrOfWorkers: %d", n))
  +   stopifnot(n == 1L)
  + 
  +   plan(strategy)
  +   n <- nbrOfWorkers()
  +   message(sprintf("nbrOfWorkers: %d", n))
  +   stopifnot(n == 1L)
  + } ## for (strategy ...)
  Type of future: sequential
  nbrOfWorkers: 1
  [23:40:38.136] plan(): Setting new future strategy stack:
  [23:40:38.137] List of future strategies:
  [23:40:38.137] 1. sequential:
  [23:40:38.137]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [23:40:38.137]    - tweaked: FALSE
  [23:40:38.137]    - call: plan(strategy)
  [23:40:38.229] plan(): nbrOfWorkers() = 1
  nbrOfWorkers: 1
  Type of future: transparent
  nbrOfWorkers: 1
  [23:40:38.230] plan(): Setting new future strategy stack:
  [23:40:38.231] List of future strategies:
  [23:40:38.231] 1. transparent:
  [23:40:38.231]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = FALSE, local = FALSE, earlySignal = TRUE, label = NULL, ...)
  [23:40:38.231]    - tweaked: FALSE
  [23:40:38.231]    - call: plan(strategy)
  [23:40:38.232] plan(): nbrOfWorkers() = 1
  nbrOfWorkers: 1
  > 
  > 
  > strategies <- c("cluster", "multiprocess", "multisession", "multicore")
  > strategies <- intersect(strategies, supportedStrategies())
  > cores <- availableCores()
  > message("Number of available cores: ", cores)
  Number of available cores: 2
  > workers <- availableWorkers()
  > nworkers <- length(workers)
  > message(sprintf("Available workers: [n = %d] %s", nworkers, hpaste(sQuote(workers))))
  Available workers: [n = 2] 'localhost', 'localhost'
  > 
  > allButOneCore <- function() max(1L, future::availableCores() - 1L)
  > allButOneWorker <- function() {
  +   w <- future::availableWorkers()
  +   if (length(w) > 1) w[-1] else w
  + }
  > 
  > for (strategy in strategies) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  + 
  +   message("Type of future: ", strategy)
  + 
  +   evaluator <- get(strategy, mode = "function")
  +   n <- nbrOfWorkers(evaluator)
  +   message(sprintf("nbrOfWorkers: %d", n))
  +   stopifnot(n == nworkers)
  + 
  +   plan(strategy)
  +   n <- nbrOfWorkers()
  +   message(sprintf("nbrOfWorkers: %d", n))
  +   stopifnot(n == nworkers)
  + 
  +   plan(strategy, workers = allButOneCore)
  +   n <- nbrOfWorkers()
  +   message(sprintf("nbrOfWorkers: %d", n))
  +   stopifnot(n == max(1L, nworkers - 1L))
  + } ## for (strategy ...)
  > 
  > 
  > message("Type of future: cluster")
  Type of future: cluster
  > workers <- rep("localhost", times = 2L)
  > plan(cluster, workers = workers)
  [23:40:38.307] plan(): Setting new future strategy stack:
  [23:40:38.308] List of future strategies:
  [23:40:38.308] 1. cluster:
  [23:40:38.308]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = c("localhost", "localhost"), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [23:40:38.308]    - tweaked: TRUE
  [23:40:38.308]    - call: plan(cluster, workers = workers)
  [23:40:38.309] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ...
  [23:40:38.309] cluster:
  [23:40:38.309] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = c("localhost", "localhost"), user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [23:40:38.309] - tweaked: TRUE
  [23:40:38.309] - call: plan(cluster, workers = workers)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 36147
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1baa9dcd.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1baa9dcd.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1baa9dcd.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36147 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1ae7add.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1ae7add.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f1ae7add.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36147 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [23:40:55.300] getGlobalsAndPackages() ...
  [23:40:55.301] Not searching for globals
  [23:40:55.301] - globals: [0] <none>
  [23:40:55.302] getGlobalsAndPackages() ... DONE
  [23:40:55.309] Packages needed by the future expression (n = 0): <none>
  [23:40:55.309] Packages needed by future strategies (n = 0): <none>
  [23:40:55.316] {
  [23:40:55.316]     {
  [23:40:55.316]         ...future.startTime <- base::Sys.time()
  [23:40:55.316]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:40:55.316]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:40:55.316]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:40:55.316]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:40:55.316]             future.resolve.recursive = NULL, width = 80L)
  [23:40:55.316]         {
  [23:40:55.316]             {
  [23:40:55.316]                 has_future <- base::requireNamespace("future", 
  [23:40:55.316]                   quietly = TRUE)
  [23:40:55.316]                 version <- if (has_future) 
  [23:40:55.316]                   utils::packageVersion("future")
  [23:40:55.316]                 else NULL
  [23:40:55.316]                 if (!has_future || version < "1.8.0") {
  [23:40:55.316]                   info <- base::c(r_version = base::gsub("R version ", 
  [23:40:55.316]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:40:55.316]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:40:55.316]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:40:55.316]                       "release", "version")], collapse = " "), 
  [23:40:55.316]                     hostname = base::Sys.info()[["nodename"]])
  [23:40:55.316]                   info <- base::sprintf("%s: %s", base::names(info), 
  [23:40:55.316]                     info)
  [23:40:55.316]                   info <- base::paste(info, collapse = "; ")
  [23:40:55.316]                   if (!has_future) {
  [23:40:55.316]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:40:55.316]                       info)
  [23:40:55.316]                   }
  [23:40:55.316]                   else {
  [23:40:55.316]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:40:55.316]                       info, version)
  [23:40:55.316]                   }
  [23:40:55.316]                   base::stop(msg)
  [23:40:55.316]                 }
  [23:40:55.316]             }
  [23:40:55.316]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:40:55.316]         }
  [23:40:55.316]     }
  [23:40:55.316]     if (base::is.na(TRUE)) {
  [23:40:55.316]     }
  [23:40:55.316]     else {
  [23:40:55.316]         if (TRUE) {
  [23:40:55.316]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:40:55.316]                 open = "w")
  [23:40:55.316]         }
  [23:40:55.316]         else {
  [23:40:55.316]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:40:55.316]                 windows = "NUL", "/dev/null"), open = "w")
  [23:40:55.316]         }
  [23:40:55.316]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:40:55.316]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:40:55.316]             base::sink(type = "output", split = FALSE)
  [23:40:55.316]             base::close(...future.stdout)
  [23:40:55.316]         }, add = TRUE)
  [23:40:55.316]     }
  [23:40:55.316]     ...future.frame <- base::sys.nframe()
  [23:40:55.316]     ...future.conditions <- base::list()
  [23:40:55.316]     ...future.rng <- base::globalenv()$.Random.seed
  [23:40:55.316]     ...future.result <- base::tryCatch({
  [23:40:55.316]         base::withCallingHandlers({
  [23:40:55.316]             ...future.value <- base::withVisible(base::local({
  [23:40:55.316]                 ...future.sendCondition <- local({
  [23:40:55.316]                   sendCondition <- NULL
  [23:40:55.316]                   function(frame = 1L) {
  [23:40:55.316]                     if (is.function(sendCondition)) 
  [23:40:55.316]                       return(sendCondition)
  [23:40:55.316]                     ns <- getNamespace("parallel")
  [23:40:55.316]                     if (exists("sendData", mode = "function", 
  [23:40:55.316]                       envir = ns)) {
  [23:40:55.316]                       parallel_sendData <- get("sendData", mode = "function", 
  [23:40:55.316]                         envir = ns)
  [23:40:55.316]                       envir <- sys.frame(frame)
  [23:40:55.316]                       master <- NULL
  [23:40:55.316]                       while (!identical(envir, .GlobalEnv) && 
  [23:40:55.316]                         !identical(envir, emptyenv())) {
  [23:40:55.316]                         if (exists("master", mode = "list", envir = envir, 
  [23:40:55.316]                           inherits = FALSE)) {
  [23:40:55.316]                           master <- get("master", mode = "list", 
  [23:40:55.316]                             envir = envir, inherits = FALSE)
  [23:40:55.316]                           if (inherits(master, "SOCKnode")) {
  [23:40:55.316]                             sendCondition <<- function(cond) {
  [23:40:55.316]                               data <- list(type = "VALUE", value = cond, 
  [23:40:55.316]                                 success = TRUE)
  [23:40:55.316]                               parallel_sendData(master, data)
  [23:40:55.316]                             }
  [23:40:55.316]                             return(sendCondition)
  [23:40:55.316]                           }
  [23:40:55.316]                         }
  [23:40:55.316]                         frame <- frame + 1L
  [23:40:55.316]                         envir <- sys.frame(frame)
  [23:40:55.316]                       }
  [23:40:55.316]                     }
  [23:40:55.316]                     sendCondition <<- function(cond) NULL
  [23:40:55.316]                   }
  [23:40:55.316]                 })
  [23:40:55.316]                 withCallingHandlers({
  [23:40:55.316]                   NA
  [23:40:55.316]                 }, immediateCondition = function(cond) {
  [23:40:55.316]                   sendCondition <- ...future.sendCondition()
  [23:40:55.316]                   sendCondition(cond)
  [23:40:55.316]                   muffleCondition <- function (cond) 
  [23:40:55.316]                   {
  [23:40:55.316]                     inherits <- base::inherits
  [23:40:55.316]                     invokeRestart <- base::invokeRestart
  [23:40:55.316]                     muffled <- FALSE
  [23:40:55.316]                     if (inherits(cond, "message")) {
  [23:40:55.316]                       invokeRestart("muffleMessage")
  [23:40:55.316]                       muffled <- TRUE
  [23:40:55.316]                     }
  [23:40:55.316]                     else if (inherits(cond, "warning")) {
  [23:40:55.316]                       invokeRestart("muffleWarning")
  [23:40:55.316]                       muffled <- TRUE
  [23:40:55.316]                     }
  [23:40:55.316]                     else if (inherits(cond, "condition")) {
  [23:40:55.316]                       computeRestarts <- base::computeRestarts
  [23:40:55.316]                       grepl <- base::grepl
  [23:40:55.316]                       is.null <- base::is.null
  [23:40:55.316]                       restarts <- computeRestarts(cond)
  [23:40:55.316]                       for (restart in restarts) {
  [23:40:55.316]                         name <- restart$name
  [23:40:55.316]                         if (is.null(name)) 
  [23:40:55.316]                           next
  [23:40:55.316]                         if (!grepl("^muffle", name)) 
  [23:40:55.316]                           next
  [23:40:55.316]                         invokeRestart(restart)
  [23:40:55.316]                         muffled <- TRUE
  [23:40:55.316]                         break
  [23:40:55.316]                       }
  [23:40:55.316]                     }
  [23:40:55.316]                     invisible(muffled)
  [23:40:55.316]                   }
  [23:40:55.316]                   muffleCondition(cond)
  [23:40:55.316]                 })
  [23:40:55.316]             }))
  [23:40:55.316]             future::FutureResult(value = ...future.value$value, 
  [23:40:55.316]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:40:55.316]                   ...future.rng), started = ...future.startTime, 
  [23:40:55.316]                 version = "1.8")
  [23:40:55.316]         }, condition = base::local({
  [23:40:55.316]             c <- base::c
  [23:40:55.316]             inherits <- base::inherits
  [23:40:55.316]             invokeRestart <- base::invokeRestart
  [23:40:55.316]             length <- base::length
  [23:40:55.316]             list <- base::list
  [23:40:55.316]             seq.int <- base::seq.int
  [23:40:55.316]             signalCondition <- base::signalCondition
  [23:40:55.316]             sys.calls <- base::sys.calls
  [23:40:55.316]             Sys.time <- base::Sys.time
  [23:40:55.316]             `[[` <- base::`[[`
  [23:40:55.316]             `+` <- base::`+`
  [23:40:55.316]             `<<-` <- base::`<<-`
  [23:40:55.316]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:40:55.316]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [23:40:55.316]                   3L)]
  [23:40:55.316]             }
  [23:40:55.316]             function(cond) {
  [23:40:55.316]                 if (inherits(cond, "error")) {
  [23:40:55.316]                   ...future.conditions[[length(...future.conditions) + 
  [23:40:55.316]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:40:55.316]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:40:55.316]                   signalCondition(cond)
  [23:40:55.316]                 }
  [23:40:55.316]                 else if (inherits(cond, c("condition", "immediateCondition"
  [23:40:55.316]                 ))) {
  [23:40:55.316]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [23:40:55.316]                   ...future.conditions[[length(...future.conditions) + 
  [23:40:55.316]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:40:55.316]                   if (!signal) {
  [23:40:55.316]                     muffleCondition <- function (cond) 
  [23:40:55.316]                     {
  [23:40:55.316]                       inherits <- base::inherits
  [23:40:55.316]                       invokeRestart <- base::invokeRestart
  [23:40:55.316]                       muffled <- FALSE
  [23:40:55.316]                       if (inherits(cond, "message")) {
  [23:40:55.316]                         invokeRestart("muffleMessage")
  [23:40:55.316]                         muffled <- TRUE
  [23:40:55.316]                       }
  [23:40:55.316]                       else if (inherits(cond, "warning")) {
  [23:40:55.316]                         invokeRestart("muffleWarning")
  [23:40:55.316]                         muffled <- TRUE
  [23:40:55.316]                       }
  [23:40:55.316]                       else if (inherits(cond, "condition")) {
  [23:40:55.316]                         computeRestarts <- base::computeRestarts
  [23:40:55.316]                         grepl <- base::grepl
  [23:40:55.316]                         is.null <- base::is.null
  [23:40:55.316]                         restarts <- computeRestarts(cond)
  [23:40:55.316]                         for (restart in restarts) {
  [23:40:55.316]                           name <- restart$name
  [23:40:55.316]                           if (is.null(name)) 
  [23:40:55.316]                             next
  [23:40:55.316]                           if (!grepl("^muffle", name)) 
  [23:40:55.316]                             next
  [23:40:55.316]                           invokeRestart(restart)
  [23:40:55.316]                           muffled <- TRUE
  [23:40:55.316]                           break
  [23:40:55.316]                         }
  [23:40:55.316]                       }
  [23:40:55.316]                       invisible(muffled)
  [23:40:55.316]                     }
  [23:40:55.316]                     muffleCondition(cond)
  [23:40:55.316]                   }
  [23:40:55.316]                 }
  [23:40:55.316]             }
  [23:40:55.316]         }))
  [23:40:55.316]     }, error = function(ex) {
  [23:40:55.316]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:40:55.316]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:40:55.316]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:40:55.316]     }, finally = {
  [23:40:55.316]         {
  [23:40:55.316]             NULL
  [23:40:55.316]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:40:55.316]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:40:55.316]                 globals = TRUE, persistent = FALSE, workers = c("localhost", 
  [23:40:55.316]                 "localhost"), user = NULL, revtunnel = TRUE, 
  [23:40:55.316]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [23:40:55.316]                 label = NULL, ...) 
  [23:40:55.316]             {
  [23:40:55.316]                 if (substitute) 
  [23:40:55.316]                   expr <- substitute(expr)
  [23:40:55.316]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [23:40:55.316]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:40:55.316]                   globals = globals, persistent = persistent, 
  [23:40:55.316]                   workers = workers, user = user, revtunnel = revtunnel, 
  [23:40:55.316]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [23:40:55.316]                   label = label, ...)
  [23:40:55.316]                 if (!future$lazy) 
  [23:40:55.316]                   future <- run(future)
  [23:40:55.316]                 invisible(future)
  [23:40:55.316]             }), .cleanup = FALSE, .init = FALSE)
  [23:40:55.316]         }
  [23:40:55.316]         base::options(...future.oldOptions)
  [23:40:55.316]     })
  [23:40:55.316]     Sys.time
  [23:40:55.316]     if (base::is.na(TRUE)) {
  [23:40:55.316]     }
  [23:40:55.316]     else {
  [23:40:55.316]         base::sink(type = "output", split = FALSE)
  [23:40:55.316]         if (TRUE) {
  [23:40:55.316]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:40:55.316]         }
  [23:40:55.316]         else {
  [23:40:55.316]             ...future.result["stdout"] <- base::list(NULL)
  [23:40:55.316]         }
  [23:40:55.316]         base::close(...future.stdout)
  [23:40:55.316]         ...future.stdout <- NULL
  [23:40:55.316]     }
  [23:40:55.316]     ...future.result$conditions <- ...future.conditions
  [23:40:55.316]     ...future.result
  [23:40:55.316] }
  [23:40:55.329] ClusterFuture started
  [23:40:55.330] result() for ClusterFuture ...
  [23:40:55.332] receiveMessageFromWorker() for ClusterFuture ...
  [23:40:55.332] - Validating connection of ClusterFuture
  [23:40:55.529] - received message: FutureResult
  [23:40:55.529] - Received FutureResult
  [23:40:55.535] - Erased future from FutureRegistry
  [23:40:55.536] result() for ClusterFuture ...
  [23:40:55.537] - result already collected: FutureResult
  [23:40:55.537] result() for ClusterFuture ... done
  [23:40:55.537] receiveMessageFromWorker() for ClusterFuture ... done
  [23:40:55.538] result() for ClusterFuture ... done
  [23:40:55.538] result() for ClusterFuture ...
  [23:40:55.538] - result already collected: FutureResult
  [23:40:55.538] result() for ClusterFuture ... done
  [23:40:55.539] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [23:40:55.539] plan(): nbrOfWorkers() = 2
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 2
  > stopifnot(n == length(workers))
  > plan(cluster, workers = allButOneWorker)
  [23:40:55.540] plan(): Setting new future strategy stack:
  [23:40:55.541] List of future strategies:
  [23:40:55.541] 1. cluster:
  [23:40:55.541]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = "<function ()  >", user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [23:40:55.541]    - tweaked: TRUE
  [23:40:55.541]    - call: plan(cluster, workers = allButOneWorker)
  [23:40:55.559] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ...
  [23:40:55.559] cluster:
  [23:40:55.559] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = "<function ()  >", user = NULL, revtunnel = TRUE, homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [23:40:55.559] - tweaked: TRUE
  [23:40:55.559] - call: plan(cluster, workers = allButOneWorker)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 30722
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f3f87e352.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f3f87e352.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f3f87e352.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=30722 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 1 ... done
  [23:41:04.249] getGlobalsAndPackages() ...
  [23:41:04.249] Not searching for globals
  [23:41:04.250] - globals: [0] <none>
  [23:41:04.250] getGlobalsAndPackages() ... DONE
  [23:41:04.255] Packages needed by the future expression (n = 0): <none>
  [23:41:04.255] Packages needed by future strategies (n = 0): <none>
  [23:41:04.274] {
  [23:41:04.274]     {
  [23:41:04.274]         ...future.startTime <- base::Sys.time()
  [23:41:04.274]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:41:04.274]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:41:04.274]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:41:04.274]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:41:04.274]             future.resolve.recursive = NULL, width = 80L)
  [23:41:04.274]         {
  [23:41:04.274]             {
  [23:41:04.274]                 has_future <- base::requireNamespace("future", 
  [23:41:04.274]                   quietly = TRUE)
  [23:41:04.274]                 version <- if (has_future) 
  [23:41:04.274]                   utils::packageVersion("future")
  [23:41:04.274]                 else NULL
  [23:41:04.274]                 if (!has_future || version < "1.8.0") {
  [23:41:04.274]                   info <- base::c(r_version = base::gsub("R version ", 
  [23:41:04.274]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:41:04.274]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:41:04.274]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:41:04.274]                       "release", "version")], collapse = " "), 
  [23:41:04.274]                     hostname = base::Sys.info()[["nodename"]])
  [23:41:04.274]                   info <- base::sprintf("%s: %s", base::names(info), 
  [23:41:04.274]                     info)
  [23:41:04.274]                   info <- base::paste(info, collapse = "; ")
  [23:41:04.274]                   if (!has_future) {
  [23:41:04.274]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:41:04.274]                       info)
  [23:41:04.274]                   }
  [23:41:04.274]                   else {
  [23:41:04.274]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:41:04.274]                       info, version)
  [23:41:04.274]                   }
  [23:41:04.274]                   base::stop(msg)
  [23:41:04.274]                 }
  [23:41:04.274]             }
  [23:41:04.274]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:41:04.274]         }
  [23:41:04.274]     }
  [23:41:04.274]     if (base::is.na(TRUE)) {
  [23:41:04.274]     }
  [23:41:04.274]     else {
  [23:41:04.274]         if (TRUE) {
  [23:41:04.274]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:41:04.274]                 open = "w")
  [23:41:04.274]         }
  [23:41:04.274]         else {
  [23:41:04.274]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:41:04.274]                 windows = "NUL", "/dev/null"), open = "w")
  [23:41:04.274]         }
  [23:41:04.274]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:41:04.274]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:41:04.274]             base::sink(type = "output", split = FALSE)
  [23:41:04.274]             base::close(...future.stdout)
  [23:41:04.274]         }, add = TRUE)
  [23:41:04.274]     }
  [23:41:04.274]     ...future.frame <- base::sys.nframe()
  [23:41:04.274]     ...future.conditions <- base::list()
  [23:41:04.274]     ...future.rng <- base::globalenv()$.Random.seed
  [23:41:04.274]     ...future.result <- base::tryCatch({
  [23:41:04.274]         base::withCallingHandlers({
  [23:41:04.274]             ...future.value <- base::withVisible(base::local({
  [23:41:04.274]                 ...future.sendCondition <- local({
  [23:41:04.274]                   sendCondition <- NULL
  [23:41:04.274]                   function(frame = 1L) {
  [23:41:04.274]                     if (is.function(sendCondition)) 
  [23:41:04.274]                       return(sendCondition)
  [23:41:04.274]                     ns <- getNamespace("parallel")
  [23:41:04.274]                     if (exists("sendData", mode = "function", 
  [23:41:04.274]                       envir = ns)) {
  [23:41:04.274]                       parallel_sendData <- get("sendData", mode = "function", 
  [23:41:04.274]                         envir = ns)
  [23:41:04.274]                       envir <- sys.frame(frame)
  [23:41:04.274]                       master <- NULL
  [23:41:04.274]                       while (!identical(envir, .GlobalEnv) && 
  [23:41:04.274]                         !identical(envir, emptyenv())) {
  [23:41:04.274]                         if (exists("master", mode = "list", envir = envir, 
  [23:41:04.274]                           inherits = FALSE)) {
  [23:41:04.274]                           master <- get("master", mode = "list", 
  [23:41:04.274]                             envir = envir, inherits = FALSE)
  [23:41:04.274]                           if (inherits(master, "SOCKnode")) {
  [23:41:04.274]                             sendCondition <<- function(cond) {
  [23:41:04.274]                               data <- list(type = "VALUE", value = cond, 
  [23:41:04.274]                                 success = TRUE)
  [23:41:04.274]                               parallel_sendData(master, data)
  [23:41:04.274]                             }
  [23:41:04.274]                             return(sendCondition)
  [23:41:04.274]                           }
  [23:41:04.274]                         }
  [23:41:04.274]                         frame <- frame + 1L
  [23:41:04.274]                         envir <- sys.frame(frame)
  [23:41:04.274]                       }
  [23:41:04.274]                     }
  [23:41:04.274]                     sendCondition <<- function(cond) NULL
  [23:41:04.274]                   }
  [23:41:04.274]                 })
  [23:41:04.274]                 withCallingHandlers({
  [23:41:04.274]                   NA
  [23:41:04.274]                 }, immediateCondition = function(cond) {
  [23:41:04.274]                   sendCondition <- ...future.sendCondition()
  [23:41:04.274]                   sendCondition(cond)
  [23:41:04.274]                   muffleCondition <- function (cond) 
  [23:41:04.274]                   {
  [23:41:04.274]                     inherits <- base::inherits
  [23:41:04.274]                     invokeRestart <- base::invokeRestart
  [23:41:04.274]                     muffled <- FALSE
  [23:41:04.274]                     if (inherits(cond, "message")) {
  [23:41:04.274]                       invokeRestart("muffleMessage")
  [23:41:04.274]                       muffled <- TRUE
  [23:41:04.274]                     }
  [23:41:04.274]                     else if (inherits(cond, "warning")) {
  [23:41:04.274]                       invokeRestart("muffleWarning")
  [23:41:04.274]                       muffled <- TRUE
  [23:41:04.274]                     }
  [23:41:04.274]                     else if (inherits(cond, "condition")) {
  [23:41:04.274]                       computeRestarts <- base::computeRestarts
  [23:41:04.274]                       grepl <- base::grepl
  [23:41:04.274]                       is.null <- base::is.null
  [23:41:04.274]                       restarts <- computeRestarts(cond)
  [23:41:04.274]                       for (restart in restarts) {
  [23:41:04.274]                         name <- restart$name
  [23:41:04.274]                         if (is.null(name)) 
  [23:41:04.274]                           next
  [23:41:04.274]                         if (!grepl("^muffle", name)) 
  [23:41:04.274]                           next
  [23:41:04.274]                         invokeRestart(restart)
  [23:41:04.274]                         muffled <- TRUE
  [23:41:04.274]                         break
  [23:41:04.274]                       }
  [23:41:04.274]                     }
  [23:41:04.274]                     invisible(muffled)
  [23:41:04.274]                   }
  [23:41:04.274]                   muffleCondition(cond)
  [23:41:04.274]                 })
  [23:41:04.274]             }))
  [23:41:04.274]             future::FutureResult(value = ...future.value$value, 
  [23:41:04.274]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:04.274]                   ...future.rng), started = ...future.startTime, 
  [23:41:04.274]                 version = "1.8")
  [23:41:04.274]         }, condition = base::local({
  [23:41:04.274]             c <- base::c
  [23:41:04.274]             inherits <- base::inherits
  [23:41:04.274]             invokeRestart <- base::invokeRestart
  [23:41:04.274]             length <- base::length
  [23:41:04.274]             list <- base::list
  [23:41:04.274]             seq.int <- base::seq.int
  [23:41:04.274]             signalCondition <- base::signalCondition
  [23:41:04.274]             sys.calls <- base::sys.calls
  [23:41:04.274]             Sys.time <- base::Sys.time
  [23:41:04.274]             `[[` <- base::`[[`
  [23:41:04.274]             `+` <- base::`+`
  [23:41:04.274]             `<<-` <- base::`<<-`
  [23:41:04.274]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:41:04.274]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [23:41:04.274]                   3L)]
  [23:41:04.274]             }
  [23:41:04.274]             function(cond) {
  [23:41:04.274]                 if (inherits(cond, "error")) {
  [23:41:04.274]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:04.274]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:41:04.274]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:41:04.274]                   signalCondition(cond)
  [23:41:04.274]                 }
  [23:41:04.274]                 else if (inherits(cond, c("condition", "immediateCondition"
  [23:41:04.274]                 ))) {
  [23:41:04.274]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [23:41:04.274]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:04.274]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:41:04.274]                   if (!signal) {
  [23:41:04.274]                     muffleCondition <- function (cond) 
  [23:41:04.274]                     {
  [23:41:04.274]                       inherits <- base::inherits
  [23:41:04.274]                       invokeRestart <- base::invokeRestart
  [23:41:04.274]                       muffled <- FALSE
  [23:41:04.274]                       if (inherits(cond, "message")) {
  [23:41:04.274]                         invokeRestart("muffleMessage")
  [23:41:04.274]                         muffled <- TRUE
  [23:41:04.274]                       }
  [23:41:04.274]                       else if (inherits(cond, "warning")) {
  [23:41:04.274]                         invokeRestart("muffleWarning")
  [23:41:04.274]                         muffled <- TRUE
  [23:41:04.274]                       }
  [23:41:04.274]                       else if (inherits(cond, "condition")) {
  [23:41:04.274]                         computeRestarts <- base::computeRestarts
  [23:41:04.274]                         grepl <- base::grepl
  [23:41:04.274]                         is.null <- base::is.null
  [23:41:04.274]                         restarts <- computeRestarts(cond)
  [23:41:04.274]                         for (restart in restarts) {
  [23:41:04.274]                           name <- restart$name
  [23:41:04.274]                           if (is.null(name)) 
  [23:41:04.274]                             next
  [23:41:04.274]                           if (!grepl("^muffle", name)) 
  [23:41:04.274]                             next
  [23:41:04.274]                           invokeRestart(restart)
  [23:41:04.274]                           muffled <- TRUE
  [23:41:04.274]                           break
  [23:41:04.274]                         }
  [23:41:04.274]                       }
  [23:41:04.274]                       invisible(muffled)
  [23:41:04.274]                     }
  [23:41:04.274]                     muffleCondition(cond)
  [23:41:04.274]                   }
  [23:41:04.274]                 }
  [23:41:04.274]             }
  [23:41:04.274]         }))
  [23:41:04.274]     }, error = function(ex) {
  [23:41:04.274]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:41:04.274]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:04.274]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:41:04.274]     }, finally = {
  [23:41:04.274]         {
  [23:41:04.274]             NULL
  [23:41:04.274]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:41:04.274]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:41:04.274]                 globals = TRUE, persistent = FALSE, workers = function () 
  [23:41:04.274]                 {
  [23:41:04.274]                   w <- future::availableWorkers()
  [23:41:04.274]                   if (length(w) > 1) 
  [23:41:04.274]                     w[-1]
  [23:41:04.274]                   else w
  [23:41:04.274]                 }, user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [23:41:04.274]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [23:41:04.274]                 ...) 
  [23:41:04.274]             {
  [23:41:04.274]                 if (substitute) 
  [23:41:04.274]                   expr <- substitute(expr)
  [23:41:04.274]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [23:41:04.274]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:41:04.274]                   globals = globals, persistent = persistent, 
  [23:41:04.274]                   workers = workers, user = user, revtunnel = revtunnel, 
  [23:41:04.274]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [23:41:04.274]                   label = label, ...)
  [23:41:04.274]                 if (!future$lazy) 
  [23:41:04.274]                   future <- run(future)
  [23:41:04.274]                 invisible(future)
  [23:41:04.274]             }), .cleanup = FALSE, .init = FALSE)
  [23:41:04.274]         }
  [23:41:04.274]         base::options(...future.oldOptions)
  [23:41:04.274]     })
  [23:41:04.274]     Sys.time
  [23:41:04.274]     if (base::is.na(TRUE)) {
  [23:41:04.274]     }
  [23:41:04.274]     else {
  [23:41:04.274]         base::sink(type = "output", split = FALSE)
  [23:41:04.274]         if (TRUE) {
  [23:41:04.274]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:41:04.274]         }
  [23:41:04.274]         else {
  [23:41:04.274]             ...future.result["stdout"] <- base::list(NULL)
  [23:41:04.274]         }
  [23:41:04.274]         base::close(...future.stdout)
  [23:41:04.274]         ...future.stdout <- NULL
  [23:41:04.274]     }
  [23:41:04.274]     ...future.result$conditions <- ...future.conditions
  [23:41:04.274]     ...future.result
  [23:41:04.274] }
  [23:41:04.280] ClusterFuture started
  [23:41:04.281] result() for ClusterFuture ...
  [23:41:04.281] receiveMessageFromWorker() for ClusterFuture ...
  [23:41:04.281] - Validating connection of ClusterFuture
  [23:41:04.513] - received message: FutureResult
  [23:41:04.514] - Received FutureResult
  [23:41:04.514] - Erased future from FutureRegistry
  [23:41:04.515] result() for ClusterFuture ...
  [23:41:04.515] - result already collected: FutureResult
  [23:41:04.515] result() for ClusterFuture ... done
  [23:41:04.516] receiveMessageFromWorker() for ClusterFuture ... done
  [23:41:04.516] result() for ClusterFuture ... done
  [23:41:04.517] result() for ClusterFuture ...
  [23:41:04.517] - result already collected: FutureResult
  [23:41:04.517] result() for ClusterFuture ... done
  [23:41:04.518] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [23:41:04.535] plan(): nbrOfWorkers() = 1
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 1
  > stopifnot(n == max(1L, nworkers - 1L))
  > 
  > message("Type of future: remote")
  Type of future: remote
  > workers <- rep("localhost", times = 2L)
  > plan(remote, workers = workers)
  [23:41:04.538] plan(): Setting new future strategy stack:
  [23:41:04.538] List of future strategies:
  [23:41:04.538] 1. remote:
  [23:41:04.538]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = TRUE, workers = c("localhost", "localhost"), user = NULL, revtunnel = TRUE, gc = FALSE, earlySignal = FALSE, myip = NULL, label = NULL, ...)
  [23:41:04.538]    - tweaked: TRUE
  [23:41:04.538]    - call: plan(remote, workers = workers)
  [23:41:04.539] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ...
  [23:41:04.540] remote:
  [23:41:04.540] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = TRUE, workers = c("localhost", "localhost"), user = NULL, revtunnel = TRUE, gc = FALSE, earlySignal = FALSE, myip = NULL, label = NULL, ...)
  [23:41:04.540] - tweaked: TRUE
  [23:41:04.540] - call: plan(remote, workers = workers)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 28930
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f5631c9ae.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f5631c9ae.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f5631c9ae.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=28930 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 2 ... done
  [local output] Creating node 2 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f31a84c35.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f31a84c35.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f31a84c35.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=28930 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #2 on 'localhost' to connect back
  [local output] Connection with worker #2 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 2 of 2 ... done
  [23:41:21.308] getGlobalsAndPackages() ...
  [23:41:21.309] Not searching for globals
  [23:41:21.309] - globals: [0] <none>
  [23:41:21.310] getGlobalsAndPackages() ... DONE
  [23:41:21.327] Packages needed by the future expression (n = 0): <none>
  [23:41:21.328] Packages needed by future strategies (n = 0): <none>
  [23:41:21.334] {
  [23:41:21.334]     {
  [23:41:21.334]         ...future.startTime <- base::Sys.time()
  [23:41:21.334]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:41:21.334]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:41:21.334]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:41:21.334]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:41:21.334]             future.resolve.recursive = NULL, width = 80L)
  [23:41:21.334]         {
  [23:41:21.334]             {
  [23:41:21.334]                 has_future <- base::requireNamespace("future", 
  [23:41:21.334]                   quietly = TRUE)
  [23:41:21.334]                 version <- if (has_future) 
  [23:41:21.334]                   utils::packageVersion("future")
  [23:41:21.334]                 else NULL
  [23:41:21.334]                 if (!has_future || version < "1.8.0") {
  [23:41:21.334]                   info <- base::c(r_version = base::gsub("R version ", 
  [23:41:21.334]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:41:21.334]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:41:21.334]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:41:21.334]                       "release", "version")], collapse = " "), 
  [23:41:21.334]                     hostname = base::Sys.info()[["nodename"]])
  [23:41:21.334]                   info <- base::sprintf("%s: %s", base::names(info), 
  [23:41:21.334]                     info)
  [23:41:21.334]                   info <- base::paste(info, collapse = "; ")
  [23:41:21.334]                   if (!has_future) {
  [23:41:21.334]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:41:21.334]                       info)
  [23:41:21.334]                   }
  [23:41:21.334]                   else {
  [23:41:21.334]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:41:21.334]                       info, version)
  [23:41:21.334]                   }
  [23:41:21.334]                   base::stop(msg)
  [23:41:21.334]                 }
  [23:41:21.334]             }
  [23:41:21.334]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:41:21.334]         }
  [23:41:21.334]     }
  [23:41:21.334]     if (base::is.na(TRUE)) {
  [23:41:21.334]     }
  [23:41:21.334]     else {
  [23:41:21.334]         if (TRUE) {
  [23:41:21.334]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:41:21.334]                 open = "w")
  [23:41:21.334]         }
  [23:41:21.334]         else {
  [23:41:21.334]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:41:21.334]                 windows = "NUL", "/dev/null"), open = "w")
  [23:41:21.334]         }
  [23:41:21.334]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:41:21.334]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:41:21.334]             base::sink(type = "output", split = FALSE)
  [23:41:21.334]             base::close(...future.stdout)
  [23:41:21.334]         }, add = TRUE)
  [23:41:21.334]     }
  [23:41:21.334]     ...future.frame <- base::sys.nframe()
  [23:41:21.334]     ...future.conditions <- base::list()
  [23:41:21.334]     ...future.rng <- base::globalenv()$.Random.seed
  [23:41:21.334]     ...future.result <- base::tryCatch({
  [23:41:21.334]         base::withCallingHandlers({
  [23:41:21.334]             ...future.value <- base::withVisible({
  [23:41:21.334]                 ...future.sendCondition <- local({
  [23:41:21.334]                   sendCondition <- NULL
  [23:41:21.334]                   function(frame = 1L) {
  [23:41:21.334]                     if (is.function(sendCondition)) 
  [23:41:21.334]                       return(sendCondition)
  [23:41:21.334]                     ns <- getNamespace("parallel")
  [23:41:21.334]                     if (exists("sendData", mode = "function", 
  [23:41:21.334]                       envir = ns)) {
  [23:41:21.334]                       parallel_sendData <- get("sendData", mode = "function", 
  [23:41:21.334]                         envir = ns)
  [23:41:21.334]                       envir <- sys.frame(frame)
  [23:41:21.334]                       master <- NULL
  [23:41:21.334]                       while (!identical(envir, .GlobalEnv) && 
  [23:41:21.334]                         !identical(envir, emptyenv())) {
  [23:41:21.334]                         if (exists("master", mode = "list", envir = envir, 
  [23:41:21.334]                           inherits = FALSE)) {
  [23:41:21.334]                           master <- get("master", mode = "list", 
  [23:41:21.334]                             envir = envir, inherits = FALSE)
  [23:41:21.334]                           if (inherits(master, "SOCKnode")) {
  [23:41:21.334]                             sendCondition <<- function(cond) {
  [23:41:21.334]                               data <- list(type = "VALUE", value = cond, 
  [23:41:21.334]                                 success = TRUE)
  [23:41:21.334]                               parallel_sendData(master, data)
  [23:41:21.334]                             }
  [23:41:21.334]                             return(sendCondition)
  [23:41:21.334]                           }
  [23:41:21.334]                         }
  [23:41:21.334]                         frame <- frame + 1L
  [23:41:21.334]                         envir <- sys.frame(frame)
  [23:41:21.334]                       }
  [23:41:21.334]                     }
  [23:41:21.334]                     sendCondition <<- function(cond) NULL
  [23:41:21.334]                   }
  [23:41:21.334]                 })
  [23:41:21.334]                 withCallingHandlers({
  [23:41:21.334]                   NA
  [23:41:21.334]                 }, immediateCondition = function(cond) {
  [23:41:21.334]                   sendCondition <- ...future.sendCondition()
  [23:41:21.334]                   sendCondition(cond)
  [23:41:21.334]                   muffleCondition <- function (cond) 
  [23:41:21.334]                   {
  [23:41:21.334]                     inherits <- base::inherits
  [23:41:21.334]                     invokeRestart <- base::invokeRestart
  [23:41:21.334]                     muffled <- FALSE
  [23:41:21.334]                     if (inherits(cond, "message")) {
  [23:41:21.334]                       invokeRestart("muffleMessage")
  [23:41:21.334]                       muffled <- TRUE
  [23:41:21.334]                     }
  [23:41:21.334]                     else if (inherits(cond, "warning")) {
  [23:41:21.334]                       invokeRestart("muffleWarning")
  [23:41:21.334]                       muffled <- TRUE
  [23:41:21.334]                     }
  [23:41:21.334]                     else if (inherits(cond, "condition")) {
  [23:41:21.334]                       computeRestarts <- base::computeRestarts
  [23:41:21.334]                       grepl <- base::grepl
  [23:41:21.334]                       is.null <- base::is.null
  [23:41:21.334]                       restarts <- computeRestarts(cond)
  [23:41:21.334]                       for (restart in restarts) {
  [23:41:21.334]                         name <- restart$name
  [23:41:21.334]                         if (is.null(name)) 
  [23:41:21.334]                           next
  [23:41:21.334]                         if (!grepl("^muffle", name)) 
  [23:41:21.334]                           next
  [23:41:21.334]                         invokeRestart(restart)
  [23:41:21.334]                         muffled <- TRUE
  [23:41:21.334]                         break
  [23:41:21.334]                       }
  [23:41:21.334]                     }
  [23:41:21.334]                     invisible(muffled)
  [23:41:21.334]                   }
  [23:41:21.334]                   muffleCondition(cond)
  [23:41:21.334]                 })
  [23:41:21.334]             })
  [23:41:21.334]             future::FutureResult(value = ...future.value$value, 
  [23:41:21.334]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:21.334]                   ...future.rng), started = ...future.startTime, 
  [23:41:21.334]                 version = "1.8")
  [23:41:21.334]         }, condition = base::local({
  [23:41:21.334]             c <- base::c
  [23:41:21.334]             inherits <- base::inherits
  [23:41:21.334]             invokeRestart <- base::invokeRestart
  [23:41:21.334]             length <- base::length
  [23:41:21.334]             list <- base::list
  [23:41:21.334]             seq.int <- base::seq.int
  [23:41:21.334]             signalCondition <- base::signalCondition
  [23:41:21.334]             sys.calls <- base::sys.calls
  [23:41:21.334]             Sys.time <- base::Sys.time
  [23:41:21.334]             `[[` <- base::`[[`
  [23:41:21.334]             `+` <- base::`+`
  [23:41:21.334]             `<<-` <- base::`<<-`
  [23:41:21.334]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:41:21.334]                 calls[seq.int(from = from + 6L, to = length(calls) - 
  [23:41:21.334]                   3L)]
  [23:41:21.334]             }
  [23:41:21.334]             function(cond) {
  [23:41:21.334]                 if (inherits(cond, "error")) {
  [23:41:21.334]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:21.334]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:41:21.334]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:41:21.334]                   signalCondition(cond)
  [23:41:21.334]                 }
  [23:41:21.334]                 else if (inherits(cond, c("condition", "immediateCondition"
  [23:41:21.334]                 ))) {
  [23:41:21.334]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [23:41:21.334]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:21.334]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:41:21.334]                   if (!signal) {
  [23:41:21.334]                     muffleCondition <- function (cond) 
  [23:41:21.334]                     {
  [23:41:21.334]                       inherits <- base::inherits
  [23:41:21.334]                       invokeRestart <- base::invokeRestart
  [23:41:21.334]                       muffled <- FALSE
  [23:41:21.334]                       if (inherits(cond, "message")) {
  [23:41:21.334]                         invokeRestart("muffleMessage")
  [23:41:21.334]                         muffled <- TRUE
  [23:41:21.334]                       }
  [23:41:21.334]                       else if (inherits(cond, "warning")) {
  [23:41:21.334]                         invokeRestart("muffleWarning")
  [23:41:21.334]                         muffled <- TRUE
  [23:41:21.334]                       }
  [23:41:21.334]                       else if (inherits(cond, "condition")) {
  [23:41:21.334]                         computeRestarts <- base::computeRestarts
  [23:41:21.334]                         grepl <- base::grepl
  [23:41:21.334]                         is.null <- base::is.null
  [23:41:21.334]                         restarts <- computeRestarts(cond)
  [23:41:21.334]                         for (restart in restarts) {
  [23:41:21.334]                           name <- restart$name
  [23:41:21.334]                           if (is.null(name)) 
  [23:41:21.334]                             next
  [23:41:21.334]                           if (!grepl("^muffle", name)) 
  [23:41:21.334]                             next
  [23:41:21.334]                           invokeRestart(restart)
  [23:41:21.334]                           muffled <- TRUE
  [23:41:21.334]                           break
  [23:41:21.334]                         }
  [23:41:21.334]                       }
  [23:41:21.334]                       invisible(muffled)
  [23:41:21.334]                     }
  [23:41:21.334]                     muffleCondition(cond)
  [23:41:21.334]                   }
  [23:41:21.334]                 }
  [23:41:21.334]             }
  [23:41:21.334]         }))
  [23:41:21.334]     }, error = function(ex) {
  [23:41:21.334]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:41:21.334]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:21.334]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:41:21.334]     }, finally = {
  [23:41:21.334]         {
  [23:41:21.334]             NULL
  [23:41:21.334]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:41:21.334]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:41:21.334]                 globals = TRUE, persistent = TRUE, workers = c("localhost", 
  [23:41:21.334]                 "localhost"), user = NULL, revtunnel = TRUE, 
  [23:41:21.334]                 gc = FALSE, earlySignal = FALSE, myip = NULL, 
  [23:41:21.334]                 label = NULL, ...) 
  [23:41:21.334]             {
  [23:41:21.334]                 if (substitute) 
  [23:41:21.334]                   expr <- substitute(expr)
  [23:41:21.334]                 if (is.function(workers)) 
  [23:41:21.334]                   workers <- workers()
  [23:41:21.334]                 stop_if_not(length(workers) >= 1L, !anyNA(workers))
  [23:41:21.334]                 if (is.character(workers)) {
  [23:41:21.334]                   homogeneous <- FALSE
  [23:41:21.334]                   if (all(workers %in% c("localhost", "127.0.0.1"))) {
  [23:41:21.334]                     homogeneous <- TRUE
  [23:41:21.334]                     revtunnel <- FALSE
  [23:41:21.334]                     myip <- "127.0.0.1"
  [23:41:21.334]                   }
  [23:41:21.334]                   else {
  [23:41:21.334]                     if (revtunnel) {
  [23:41:21.334]                       if (is.null(myip)) 
  [23:41:21.334]                         myip <- "127.0.0.1"
  [23:41:21.334]                     }
  [23:41:21.334]                     else if (is.null(myip)) {
  [23:41:21.334]                       myip <- "<external>"
  [23:41:21.334]                     }
  [23:41:21.334]                   }
  [23:41:21.334]                   stop_if_not(length(myip) == 1, is.character(myip), 
  [23:41:21.334]                     !is.na(myip))
  [23:41:21.334]                   if (myip == "<external>") {
  [23:41:21.334]                     myip <- myExternalIP()
  [23:41:21.334]                   }
  [23:41:21.334]                   else if (myip == "<internal>") {
  [23:41:21.334]                     myip <- myInternalIP()
  [23:41:21.334]                   }
  [23:41:21.334]                 }
  [23:41:21.334]                 else if (!inherits(workers, "cluster")) {
  [23:41:21.334]                   stop("Argument 'workers' is not of class 'cluster': ", 
  [23:41:21.334]                     class(workers)[1])
  [23:41:21.334]                 }
  [23:41:21.334]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [23:41:21.334]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:41:21.334]                   globals = globals, persistent = persistent, 
  [23:41:21.334]                   workers = workers, user = user, master = myip, 
  [23:41:21.334]                   revtunnel = revtunnel, homogeneous = homogeneous, 
  [23:41:21.334]                   gc = gc, earlySignal = earlySignal, label = label, 
  [23:41:21.334]                   ...)
  [23:41:21.334]                 if (!future$lazy) 
  [23:41:21.334]                   future <- run(future)
  [23:41:21.334]                 invisible(future)
  [23:41:21.334]             }), .cleanup = FALSE, .init = FALSE)
  [23:41:21.334]         }
  [23:41:21.334]         base::options(...future.oldOptions)
  [23:41:21.334]     })
  [23:41:21.334]     Sys.time
  [23:41:21.334]     if (base::is.na(TRUE)) {
  [23:41:21.334]     }
  [23:41:21.334]     else {
  [23:41:21.334]         base::sink(type = "output", split = FALSE)
  [23:41:21.334]         if (TRUE) {
  [23:41:21.334]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:41:21.334]         }
  [23:41:21.334]         else {
  [23:41:21.334]             ...future.result["stdout"] <- base::list(NULL)
  [23:41:21.334]         }
  [23:41:21.334]         base::close(...future.stdout)
  [23:41:21.334]         ...future.stdout <- NULL
  [23:41:21.334]     }
  [23:41:21.334]     ...future.result$conditions <- ...future.conditions
  [23:41:21.334]     ...future.result
  [23:41:21.334] }
  [23:41:21.341] ClusterFuture started
  [23:41:21.341] result() for ClusterFuture ...
  [23:41:21.341] receiveMessageFromWorker() for ClusterFuture ...
  [23:41:21.342] - Validating connection of ClusterFuture
  [23:41:21.488] - received message: FutureResult
  [23:41:21.488] - Received FutureResult
  [23:41:21.489] - Erased future from FutureRegistry
  [23:41:21.489] result() for ClusterFuture ...
  [23:41:21.489] - result already collected: FutureResult
  [23:41:21.490] result() for ClusterFuture ... done
  [23:41:21.490] receiveMessageFromWorker() for ClusterFuture ... done
  [23:41:21.490] result() for ClusterFuture ... done
  [23:41:21.491] result() for ClusterFuture ...
  [23:41:21.491] - result already collected: FutureResult
  [23:41:21.491] result() for ClusterFuture ... done
  [23:41:21.492] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [23:41:21.492] plan(): nbrOfWorkers() = 2
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 2
  > stopifnot(n == length(workers))
  > plan(remote, workers = allButOneWorker)
  [23:41:21.493] plan(): Setting new future strategy stack:
  [23:41:21.494] List of future strategies:
  [23:41:21.494] 1. remote:
  [23:41:21.494]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = TRUE, workers = "<function ()  >", user = NULL, revtunnel = TRUE, gc = FALSE, earlySignal = FALSE, myip = NULL, label = NULL, ...)
  [23:41:21.494]    - tweaked: TRUE
  [23:41:21.494]    - call: plan(remote, workers = allButOneWorker)
  [23:41:21.496] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ...
  [23:41:21.497] remote:
  [23:41:21.497] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = TRUE, workers = "<function ()  >", user = NULL, revtunnel = TRUE, gc = FALSE, earlySignal = FALSE, myip = NULL, label = NULL, ...)
  [23:41:21.497] - tweaked: TRUE
  [23:41:21.497] - call: plan(remote, workers = allButOneWorker)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 29047
  [local output] Creating node 1 of 1 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f2a7070e2.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f2a7070e2.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f2a7070e2.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=29047 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Connection with worker #1 on 'localhost' established
  [local output] - collecting session information
  [local output] Creating node 1 of 1 ... done
  [23:41:30.201] getGlobalsAndPackages() ...
  [23:41:30.201] Not searching for globals
  [23:41:30.202] - globals: [0] <none>
  [23:41:30.202] getGlobalsAndPackages() ... DONE
  [23:41:30.207] Packages needed by the future expression (n = 0): <none>
  [23:41:30.207] Packages needed by future strategies (n = 0): <none>
  [23:41:30.229] {
  [23:41:30.229]     {
  [23:41:30.229]         ...future.startTime <- base::Sys.time()
  [23:41:30.229]         ...future.oldOptions <- base::options(future.startup.script = FALSE, 
  [23:41:30.229]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [23:41:30.229]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [23:41:30.229]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [23:41:30.229]             future.resolve.recursive = NULL, width = 80L)
  [23:41:30.229]         {
  [23:41:30.229]             {
  [23:41:30.229]                 has_future <- base::requireNamespace("future", 
  [23:41:30.229]                   quietly = TRUE)
  [23:41:30.229]                 version <- if (has_future) 
  [23:41:30.229]                   utils::packageVersion("future")
  [23:41:30.229]                 else NULL
  [23:41:30.229]                 if (!has_future || version < "1.8.0") {
  [23:41:30.229]                   info <- base::c(r_version = base::gsub("R version ", 
  [23:41:30.229]                     "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)", 
  [23:41:30.229]                     base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
  [23:41:30.229]                     os = base::paste(base::Sys.info()[base::c("sysname", 
  [23:41:30.229]                       "release", "version")], collapse = " "), 
  [23:41:30.229]                     hostname = base::Sys.info()[["nodename"]])
  [23:41:30.229]                   info <- base::sprintf("%s: %s", base::names(info), 
  [23:41:30.229]                     info)
  [23:41:30.229]                   info <- base::paste(info, collapse = "; ")
  [23:41:30.229]                   if (!has_future) {
  [23:41:30.229]                     msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
  [23:41:30.229]                       info)
  [23:41:30.229]                   }
  [23:41:30.229]                   else {
  [23:41:30.229]                     msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [23:41:30.229]                       info, version)
  [23:41:30.229]                   }
  [23:41:30.229]                   base::stop(msg)
  [23:41:30.229]                 }
  [23:41:30.229]             }
  [23:41:30.229]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [23:41:30.229]         }
  [23:41:30.229]     }
  [23:41:30.229]     if (base::is.na(TRUE)) {
  [23:41:30.229]     }
  [23:41:30.229]     else {
  [23:41:30.229]         if (TRUE) {
  [23:41:30.229]             ...future.stdout <- base::rawConnection(base::raw(0L), 
  [23:41:30.229]                 open = "w")
  [23:41:30.229]         }
  [23:41:30.229]         else {
  [23:41:30.229]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
  [23:41:30.229]                 windows = "NUL", "/dev/null"), open = "w")
  [23:41:30.229]         }
  [23:41:30.229]         base::sink(...future.stdout, type = "output", split = FALSE)
  [23:41:30.229]         base::on.exit(if (!base::is.null(...future.stdout)) {
  [23:41:30.229]             base::sink(type = "output", split = FALSE)
  [23:41:30.229]             base::close(...future.stdout)
  [23:41:30.229]         }, add = TRUE)
  [23:41:30.229]     }
  [23:41:30.229]     ...future.frame <- base::sys.nframe()
  [23:41:30.229]     ...future.conditions <- base::list()
  [23:41:30.229]     ...future.rng <- base::globalenv()$.Random.seed
  [23:41:30.229]     ...future.result <- base::tryCatch({
  [23:41:30.229]         base::withCallingHandlers({
  [23:41:30.229]             ...future.value <- base::withVisible({
  [23:41:30.229]                 ...future.sendCondition <- local({
  [23:41:30.229]                   sendCondition <- NULL
  [23:41:30.229]                   function(frame = 1L) {
  [23:41:30.229]                     if (is.function(sendCondition)) 
  [23:41:30.229]                       return(sendCondition)
  [23:41:30.229]                     ns <- getNamespace("parallel")
  [23:41:30.229]                     if (exists("sendData", mode = "function", 
  [23:41:30.229]                       envir = ns)) {
  [23:41:30.229]                       parallel_sendData <- get("sendData", mode = "function", 
  [23:41:30.229]                         envir = ns)
  [23:41:30.229]                       envir <- sys.frame(frame)
  [23:41:30.229]                       master <- NULL
  [23:41:30.229]                       while (!identical(envir, .GlobalEnv) && 
  [23:41:30.229]                         !identical(envir, emptyenv())) {
  [23:41:30.229]                         if (exists("master", mode = "list", envir = envir, 
  [23:41:30.229]                           inherits = FALSE)) {
  [23:41:30.229]                           master <- get("master", mode = "list", 
  [23:41:30.229]                             envir = envir, inherits = FALSE)
  [23:41:30.229]                           if (inherits(master, "SOCKnode")) {
  [23:41:30.229]                             sendCondition <<- function(cond) {
  [23:41:30.229]                               data <- list(type = "VALUE", value = cond, 
  [23:41:30.229]                                 success = TRUE)
  [23:41:30.229]                               parallel_sendData(master, data)
  [23:41:30.229]                             }
  [23:41:30.229]                             return(sendCondition)
  [23:41:30.229]                           }
  [23:41:30.229]                         }
  [23:41:30.229]                         frame <- frame + 1L
  [23:41:30.229]                         envir <- sys.frame(frame)
  [23:41:30.229]                       }
  [23:41:30.229]                     }
  [23:41:30.229]                     sendCondition <<- function(cond) NULL
  [23:41:30.229]                   }
  [23:41:30.229]                 })
  [23:41:30.229]                 withCallingHandlers({
  [23:41:30.229]                   NA
  [23:41:30.229]                 }, immediateCondition = function(cond) {
  [23:41:30.229]                   sendCondition <- ...future.sendCondition()
  [23:41:30.229]                   sendCondition(cond)
  [23:41:30.229]                   muffleCondition <- function (cond) 
  [23:41:30.229]                   {
  [23:41:30.229]                     inherits <- base::inherits
  [23:41:30.229]                     invokeRestart <- base::invokeRestart
  [23:41:30.229]                     muffled <- FALSE
  [23:41:30.229]                     if (inherits(cond, "message")) {
  [23:41:30.229]                       invokeRestart("muffleMessage")
  [23:41:30.229]                       muffled <- TRUE
  [23:41:30.229]                     }
  [23:41:30.229]                     else if (inherits(cond, "warning")) {
  [23:41:30.229]                       invokeRestart("muffleWarning")
  [23:41:30.229]                       muffled <- TRUE
  [23:41:30.229]                     }
  [23:41:30.229]                     else if (inherits(cond, "condition")) {
  [23:41:30.229]                       computeRestarts <- base::computeRestarts
  [23:41:30.229]                       grepl <- base::grepl
  [23:41:30.229]                       is.null <- base::is.null
  [23:41:30.229]                       restarts <- computeRestarts(cond)
  [23:41:30.229]                       for (restart in restarts) {
  [23:41:30.229]                         name <- restart$name
  [23:41:30.229]                         if (is.null(name)) 
  [23:41:30.229]                           next
  [23:41:30.229]                         if (!grepl("^muffle", name)) 
  [23:41:30.229]                           next
  [23:41:30.229]                         invokeRestart(restart)
  [23:41:30.229]                         muffled <- TRUE
  [23:41:30.229]                         break
  [23:41:30.229]                       }
  [23:41:30.229]                     }
  [23:41:30.229]                     invisible(muffled)
  [23:41:30.229]                   }
  [23:41:30.229]                   muffleCondition(cond)
  [23:41:30.229]                 })
  [23:41:30.229]             })
  [23:41:30.229]             future::FutureResult(value = ...future.value$value, 
  [23:41:30.229]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:30.229]                   ...future.rng), started = ...future.startTime, 
  [23:41:30.229]                 version = "1.8")
  [23:41:30.229]         }, condition = base::local({
  [23:41:30.229]             c <- base::c
  [23:41:30.229]             inherits <- base::inherits
  [23:41:30.229]             invokeRestart <- base::invokeRestart
  [23:41:30.229]             length <- base::length
  [23:41:30.229]             list <- base::list
  [23:41:30.229]             seq.int <- base::seq.int
  [23:41:30.229]             signalCondition <- base::signalCondition
  [23:41:30.229]             sys.calls <- base::sys.calls
  [23:41:30.229]             Sys.time <- base::Sys.time
  [23:41:30.229]             `[[` <- base::`[[`
  [23:41:30.229]             `+` <- base::`+`
  [23:41:30.229]             `<<-` <- base::`<<-`
  [23:41:30.229]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [23:41:30.229]                 calls[seq.int(from = from + 6L, to = length(calls) - 
  [23:41:30.229]                   3L)]
  [23:41:30.229]             }
  [23:41:30.229]             function(cond) {
  [23:41:30.229]                 if (inherits(cond, "error")) {
  [23:41:30.229]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:30.229]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [23:41:30.229]                     cond$call), timestamp = Sys.time(), signaled = 0L)
  [23:41:30.229]                   signalCondition(cond)
  [23:41:30.229]                 }
  [23:41:30.229]                 else if (inherits(cond, c("condition", "immediateCondition"
  [23:41:30.229]                 ))) {
  [23:41:30.229]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [23:41:30.229]                   ...future.conditions[[length(...future.conditions) + 
  [23:41:30.229]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
  [23:41:30.229]                   if (!signal) {
  [23:41:30.229]                     muffleCondition <- function (cond) 
  [23:41:30.229]                     {
  [23:41:30.229]                       inherits <- base::inherits
  [23:41:30.229]                       invokeRestart <- base::invokeRestart
  [23:41:30.229]                       muffled <- FALSE
  [23:41:30.229]                       if (inherits(cond, "message")) {
  [23:41:30.229]                         invokeRestart("muffleMessage")
  [23:41:30.229]                         muffled <- TRUE
  [23:41:30.229]                       }
  [23:41:30.229]                       else if (inherits(cond, "warning")) {
  [23:41:30.229]                         invokeRestart("muffleWarning")
  [23:41:30.229]                         muffled <- TRUE
  [23:41:30.229]                       }
  [23:41:30.229]                       else if (inherits(cond, "condition")) {
  [23:41:30.229]                         computeRestarts <- base::computeRestarts
  [23:41:30.229]                         grepl <- base::grepl
  [23:41:30.229]                         is.null <- base::is.null
  [23:41:30.229]                         restarts <- computeRestarts(cond)
  [23:41:30.229]                         for (restart in restarts) {
  [23:41:30.229]                           name <- restart$name
  [23:41:30.229]                           if (is.null(name)) 
  [23:41:30.229]                             next
  [23:41:30.229]                           if (!grepl("^muffle", name)) 
  [23:41:30.229]                             next
  [23:41:30.229]                           invokeRestart(restart)
  [23:41:30.229]                           muffled <- TRUE
  [23:41:30.229]                           break
  [23:41:30.229]                         }
  [23:41:30.229]                       }
  [23:41:30.229]                       invisible(muffled)
  [23:41:30.229]                     }
  [23:41:30.229]                     muffleCondition(cond)
  [23:41:30.229]                   }
  [23:41:30.229]                 }
  [23:41:30.229]             }
  [23:41:30.229]         }))
  [23:41:30.229]     }, error = function(ex) {
  [23:41:30.229]         base::structure(base::list(value = NULL, visible = NULL, 
  [23:41:30.229]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
  [23:41:30.229]                 ...future.rng), version = "1.8"), class = "FutureResult")
  [23:41:30.229]     }, finally = {
  [23:41:30.229]         {
  [23:41:30.229]             NULL
  [23:41:30.229]             future::plan(list(function (expr, envir = parent.frame(), 
  [23:41:30.229]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [23:41:30.229]                 globals = TRUE, persistent = TRUE, workers = function () 
  [23:41:30.229]                 {
  [23:41:30.229]                   w <- future::availableWorkers()
  [23:41:30.229]                   if (length(w) > 1) 
  [23:41:30.229]                     w[-1]
  [23:41:30.229]                   else w
  [23:41:30.229]                 }, user = NULL, revtunnel = TRUE, gc = FALSE, 
  [23:41:30.229]                 earlySignal = FALSE, myip = NULL, label = NULL, 
  [23:41:30.229]                 ...) 
  [23:41:30.229]             {
  [23:41:30.229]                 if (substitute) 
  [23:41:30.229]                   expr <- substitute(expr)
  [23:41:30.229]                 if (is.function(workers)) 
  [23:41:30.229]                   workers <- workers()
  [23:41:30.229]                 stop_if_not(length(workers) >= 1L, !anyNA(workers))
  [23:41:30.229]                 if (is.character(workers)) {
  [23:41:30.229]                   homogeneous <- FALSE
  [23:41:30.229]                   if (all(workers %in% c("localhost", "127.0.0.1"))) {
  [23:41:30.229]                     homogeneous <- TRUE
  [23:41:30.229]                     revtunnel <- FALSE
  [23:41:30.229]                     myip <- "127.0.0.1"
  [23:41:30.229]                   }
  [23:41:30.229]                   else {
  [23:41:30.229]                     if (revtunnel) {
  [23:41:30.229]                       if (is.null(myip)) 
  [23:41:30.229]                         myip <- "127.0.0.1"
  [23:41:30.229]                     }
  [23:41:30.229]                     else if (is.null(myip)) {
  [23:41:30.229]                       myip <- "<external>"
  [23:41:30.229]                     }
  [23:41:30.229]                   }
  [23:41:30.229]                   stop_if_not(length(myip) == 1, is.character(myip), 
  [23:41:30.229]                     !is.na(myip))
  [23:41:30.229]                   if (myip == "<external>") {
  [23:41:30.229]                     myip <- myExternalIP()
  [23:41:30.229]                   }
  [23:41:30.229]                   else if (myip == "<internal>") {
  [23:41:30.229]                     myip <- myInternalIP()
  [23:41:30.229]                   }
  [23:41:30.229]                 }
  [23:41:30.229]                 else if (!inherits(workers, "cluster")) {
  [23:41:30.229]                   stop("Argument 'workers' is not of class 'cluster': ", 
  [23:41:30.229]                     class(workers)[1])
  [23:41:30.229]                 }
  [23:41:30.229]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [23:41:30.229]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [23:41:30.229]                   globals = globals, persistent = persistent, 
  [23:41:30.229]                   workers = workers, user = user, master = myip, 
  [23:41:30.229]                   revtunnel = revtunnel, homogeneous = homogeneous, 
  [23:41:30.229]                   gc = gc, earlySignal = earlySignal, label = label, 
  [23:41:30.229]                   ...)
  [23:41:30.229]                 if (!future$lazy) 
  [23:41:30.229]                   future <- run(future)
  [23:41:30.229]                 invisible(future)
  [23:41:30.229]             }), .cleanup = FALSE, .init = FALSE)
  [23:41:30.229]         }
  [23:41:30.229]         base::options(...future.oldOptions)
  [23:41:30.229]     })
  [23:41:30.229]     Sys.time
  [23:41:30.229]     if (base::is.na(TRUE)) {
  [23:41:30.229]     }
  [23:41:30.229]     else {
  [23:41:30.229]         base::sink(type = "output", split = FALSE)
  [23:41:30.229]         if (TRUE) {
  [23:41:30.229]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
  [23:41:30.229]         }
  [23:41:30.229]         else {
  [23:41:30.229]             ...future.result["stdout"] <- base::list(NULL)
  [23:41:30.229]         }
  [23:41:30.229]         base::close(...future.stdout)
  [23:41:30.229]         ...future.stdout <- NULL
  [23:41:30.229]     }
  [23:41:30.229]     ...future.result$conditions <- ...future.conditions
  [23:41:30.229]     ...future.result
  [23:41:30.229] }
  [23:41:30.235] ClusterFuture started
  [23:41:30.235] result() for ClusterFuture ...
  [23:41:30.236] receiveMessageFromWorker() for ClusterFuture ...
  [23:41:30.236] - Validating connection of ClusterFuture
  [23:41:30.473] - received message: FutureResult
  [23:41:30.474] - Received FutureResult
  [23:41:30.474] - Erased future from FutureRegistry
  [23:41:30.475] result() for ClusterFuture ...
  [23:41:30.475] - result already collected: FutureResult
  [23:41:30.475] result() for ClusterFuture ... done
  [23:41:30.476] receiveMessageFromWorker() for ClusterFuture ... done
  [23:41:30.476] result() for ClusterFuture ... done
  [23:41:30.476] result() for ClusterFuture ...
  [23:41:30.477] - result already collected: FutureResult
  [23:41:30.477] result() for ClusterFuture ... done
  [23:41:30.478] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [23:41:30.479] plan(): nbrOfWorkers() = 1
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 1
  > stopifnot(n == max(1L, nworkers - 1L))
  > 
  > message("Type of future: constant")
  Type of future: constant
  > n <- nbrOfWorkers(constant)
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 1
  > stopifnot(n == 1)
  > 
  > message("Type of future: <future>")
  Type of future: <future>
  > foo <- structure(function(...) NULL, class = c("future"))
  > n <- nbrOfWorkers(foo)
  > message(sprintf("nbrOfWorkers: %g", n))
  nbrOfWorkers: Inf
  > stopifnot(n >= 0, is.infinite(n))
  > 
  > 
  > message("Type of future: cluster with workers = <cluster object>")
  Type of future: cluster with workers = <cluster object>
  > 
  > workers <- makeClusterPSOCK(2L)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 37828
  [local output] Creating node 1 of 2 ...
  [local output] - setting up node
  Testing if worker's PID can be inferred: ''/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f58925ec.pid")), silent = TRUE)' -e "file.exists('/tmp/RtmpRfwZ1R/future.parent=28495.6f4f58925ec.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f58925ec.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37828 OUT=/dev/null TIMEOUT=120 XDR=TRUE
  [local output] - Exit code of system() call: 0
  [local output] Waiting for worker #1 on 'localhost' to connect back
  [local output] Detected a warning from socketConnection(): 'port 37828 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 37828 cannot be opened
  Killing worker process (PID 12551) if still alive
  [23:41:32.685] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(28495, signal = 0L)
  [1] TRUE
  Call: tools::pskill(28495, signal = 0L)
  [1] TRUE
  [23:41:32.686] - success
  [23:41:32.686] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 12551) was successfully killed: TRUE
  Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gimli'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 37828 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
   * The localhost socket connection that failed to connect to the R worker used port 37828 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-clang/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli:hornik:28495' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpRfwZ1R/future.parent=28495.6f4f58925ec.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=37828 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 12551) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: makeClusterPSOCK ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted