Running ‘000.sessionDetails.R’ [6s/8s]
  Running ‘ClusterRegistry.R’ [2s/50s]
  Running ‘Future-class.R’ [1s/19s]
  Running ‘FutureError.R’ [0s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/20s]
  Running ‘availableCores.R’ [0s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/2s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [5s/117s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [7s/27s]
  Running ‘dotdotdot.R’ [2s/17s]
  Running ‘early-signaling.R’ [2s/38s]
  Running ‘future,labels.R’ [2s/18s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/18s]
  Running ‘futureAssign_OP.R’ [3s/20s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/2s]
  Running ‘futureCall.R’ [4s/31s]
  Running ‘futureOf.R’ [0s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [17s/153s]
  Running ‘globals,NSE.R’ [2s/38s]
  Running ‘globals,formulas.R’ [3s/23s]
  Running ‘globals,manual.R’ [4s/27s]
  Running ‘globals,resolve.R’ [1s/19s]
  Running ‘globals,subassignment.R’ [3s/22s]
  Running ‘globals,toolarge.R’ [1s/18s]
  Running ‘globals,tricky.R’ [7s/28s]
  Running ‘globals,tricky_recursive.R’ [1s/17s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘immediateCondition.R’ [2s/20s]
  Running ‘invalid-owner.R’ [1s/19s]
  Running ‘makeClusterPSOCK.R’ [1s/8s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [0s/1s]
  Running ‘multicore.R’ [1s/2s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [3s/53s]
  Running ‘nbrOfWorkers.R’ [3s/70s]
  Running ‘nested_futures,mc.cores.R’ [4s/119s]
  Running ‘nested_futures.R’ [4s/76s]
  Running ‘non-exportable,connections.R’ [1s/17s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [5s/16s]
  Running ‘relaying.R’ [2s/23s]
  Running ‘remote.R’ [1s/18s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/31s]
  Running ‘resolve.R’ [6s/46s]
  Running ‘rng.R’ [6s/26s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/35s]
  Running ‘stdout.R’ [2s/21s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [5s/8s]
  Running ‘uuid.R’ [1s/2s]
  Running ‘whichIndex.R’ [0s/1s]
Running the tests in ‘tests/nbrOfWorkers.R’ failed.
Complete output:
  > source("incl/start.R")
  [20:28:03.080] plan(): Setting new future strategy stack:
  [20:28:03.081] List of future strategies:
  [20:28:03.081] 1. sequential:
  [20:28:03.081]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:28:03.081]    - tweaked: FALSE
  [20:28:03.081]    - call: future::plan("sequential")
  [20:28:03.083] 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
  [20:28:03.181] plan(): Setting new future strategy stack:
  [20:28:03.181] List of future strategies:
  [20:28:03.181] 1. sequential:
  [20:28:03.181]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:28:03.181]    - tweaked: FALSE
  [20:28:03.181]    - call: plan(strategy)
  [20:28:03.249] plan(): nbrOfWorkers() = 1
  nbrOfWorkers: 1
  Type of future: transparent
  nbrOfWorkers: 1
  [20:28:03.250] plan(): Setting new future strategy stack:
  [20:28:03.250] List of future strategies:
  [20:28:03.250] 1. transparent:
  [20:28:03.250]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = FALSE, local = FALSE, earlySignal = TRUE, label = NULL, ...)
  [20:28:03.250]    - tweaked: FALSE
  [20:28:03.250]    - call: plan(strategy)
  [20:28:03.251] 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 ...)
  Type of future: multisession
  nbrOfWorkers: 2
  [20:28:03.291] plan(): Setting new future strategy stack:
  [20:28:03.292] List of future strategies:
  [20:28:03.292] 1. multisession:
  [20:28:03.292]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:28:03.292]    - tweaked: FALSE
  [20:28:03.292]    - call: plan(strategy)
  [20:28:03.292] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:28:03.293] multisession:
  [20:28:03.293] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:28:03.293] - tweaked: FALSE
  [20:28:03.293] - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313270f4fa5a.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313270f4fa5a.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313270f4fa5a.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326d108193.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326d108193.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326d108193.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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
  [20:28:19.649] getGlobalsAndPackages() ...
  [20:28:19.650] Not searching for globals
  [20:28:19.651] - globals: [0] <none>
  [20:28:19.651] getGlobalsAndPackages() ... DONE
  [20:28:19.661] Packages needed by the future expression (n = 0): <none>
  [20:28:19.662] Packages needed by future strategies (n = 0): <none>
  [20:28:19.666] {
  [20:28:19.666]     {
  [20:28:19.666]         ...future.startTime <- Sys.time()
  [20:28:19.666]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:28:19.666]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:28:19.666]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [20:28:19.666]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:28:19.666]             future.resolve.recursive = NULL, width = 80L)
  [20:28:19.666]         {
  [20:28:19.666]             {
  [20:28:19.666]                 {
  [20:28:19.666]                   has_future <- requireNamespace("future", quietly = TRUE)
  [20:28:19.666]                   version <- if (has_future) 
  [20:28:19.666]                     packageVersion("future")
  [20:28:19.666]                   else NULL
  [20:28:19.666]                   if (!has_future || version < "1.8.0") {
  [20:28:19.666]                     info <- c(r_version = gsub("R version ", 
  [20:28:19.666]                       "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:28:19.666]                       R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:28:19.666]                       os = paste(Sys.info()[c("sysname", "release", 
  [20:28:19.666]                         "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:28:19.666]                     info <- sprintf("%s: %s", names(info), info)
  [20:28:19.666]                     info <- paste(info, collapse = "; ")
  [20:28:19.666]                     if (!has_future) {
  [20:28:19.666]                       msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:28:19.666]                         info)
  [20:28:19.666]                     }
  [20:28:19.666]                     else {
  [20:28:19.666]                       msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:28:19.666]                         info, version)
  [20:28:19.666]                     }
  [20:28:19.666]                     stop(msg)
  [20:28:19.666]                   }
  [20:28:19.666]                 }
  [20:28:19.666]                 ...future.mc.cores.old <- getOption("mc.cores")
  [20:28:19.666]                 options(mc.cores = 1L)
  [20:28:19.666]             }
  [20:28:19.666]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:28:19.666]         }
  [20:28:19.666]     }
  [20:28:19.666]     if (is.na(TRUE)) {
  [20:28:19.666]     }
  [20:28:19.666]     else {
  [20:28:19.666]         if (TRUE) {
  [20:28:19.666]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:28:19.666]         }
  [20:28:19.666]         else {
  [20:28:19.666]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:28:19.666]                 windows = "NUL", "/dev/null"), open = "w")
  [20:28:19.666]         }
  [20:28:19.666]         sink(...future.stdout, type = "output", split = FALSE)
  [20:28:19.666]         on.exit(if (!is.null(...future.stdout)) {
  [20:28:19.666]             sink(type = "output", split = FALSE)
  [20:28:19.666]             close(...future.stdout)
  [20:28:19.666]         }, add = TRUE)
  [20:28:19.666]     }
  [20:28:19.666]     ...future.frame <- sys.nframe()
  [20:28:19.666]     ...future.conditions <- list()
  [20:28:19.666]     ...future.result <- tryCatch({
  [20:28:19.666]         withCallingHandlers({
  [20:28:19.666]             ...future.value <- local(NA)
  [20:28:19.666]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:28:19.666]                 version = "1.8")
  [20:28:19.666]         }, condition = local({
  [20:28:19.666]             inherits <- base::inherits
  [20:28:19.666]             invokeRestart <- base::invokeRestart
  [20:28:19.666]             length <- base::length
  [20:28:19.666]             seq.int <- base::seq.int
  [20:28:19.666]             sys.calls <- base::sys.calls
  [20:28:19.666]             `[[` <- base::`[[`
  [20:28:19.666]             `+` <- base::`+`
  [20:28:19.666]             `<<-` <- base::`<<-`
  [20:28:19.666]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:28:19.666]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:28:19.666]                   3L)]
  [20:28:19.666]             }
  [20:28:19.666]             function(cond) {
  [20:28:19.666]                 if (inherits(cond, "error")) {
  [20:28:19.666]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:19.666]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:28:19.666]                     cond$call), timestamp = base::Sys.time(), 
  [20:28:19.666]                     signaled = 0L)
  [20:28:19.666]                   signalCondition(cond)
  [20:28:19.666]                 }
  [20:28:19.666]                 else if (inherits(cond, "condition")) {
  [20:28:19.666]                   signal <- FALSE && inherits(cond, character(0))
  [20:28:19.666]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:19.666]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:28:19.666]                   if (inherits(cond, "message")) {
  [20:28:19.666]                     if (!signal) 
  [20:28:19.666]                       invokeRestart("muffleMessage")
  [20:28:19.666]                   }
  [20:28:19.666]                   else if (inherits(cond, "warning")) {
  [20:28:19.666]                     if (!signal) 
  [20:28:19.666]                       invokeRestart("muffleWarning")
  [20:28:19.666]                   }
  [20:28:19.666]                   else {
  [20:28:19.666]                     if (!signal) {
  [20:28:19.666]                       restarts <- computeRestarts(cond)
  [20:28:19.666]                       for (restart in restarts) {
  [20:28:19.666]                         name <- restart$name
  [20:28:19.666]                         if (is.null(name)) 
  [20:28:19.666]                           next
  [20:28:19.666]                         if (!grepl("^muffle", name)) 
  [20:28:19.666]                           next
  [20:28:19.666]                         invokeRestart(restart)
  [20:28:19.666]                         break
  [20:28:19.666]                       }
  [20:28:19.666]                     }
  [20:28:19.666]                   }
  [20:28:19.666]                 }
  [20:28:19.666]             }
  [20:28:19.666]         }))
  [20:28:19.666]     }, error = function(ex) {
  [20:28:19.666]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:28:19.666]             version = "1.8"), class = "FutureResult")
  [20:28:19.666]     }, finally = {
  [20:28:19.666]         {
  [20:28:19.666]             {
  [20:28:19.666]                 options(mc.cores = ...future.mc.cores.old)
  [20:28:19.666]             }
  [20:28:19.666]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:28:19.666]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:28:19.666]                 globals = TRUE, persistent = FALSE, workers = availableCores(), 
  [20:28:19.666]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:28:19.666]                 ...) 
  [20:28:19.666]             {
  [20:28:19.666]                 if (substitute) 
  [20:28:19.666]                   expr <- substitute(expr)
  [20:28:19.666]                 if (is.function(workers)) 
  [20:28:19.666]                   workers <- workers()
  [20:28:19.666]                 workers <- as.integer(workers)
  [20:28:19.666]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:28:19.666]                   workers >= 1)
  [20:28:19.666]                 if (workers == 1L) {
  [20:28:19.666]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:28:19.666]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:28:19.666]                     local = TRUE, label = label, ...))
  [20:28:19.666]                 }
  [20:28:19.666]                 workers <- ClusterRegistry("start", workers = workers)
  [20:28:19.666]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:28:19.666]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:28:19.666]                   globals = globals, persistent = persistent, 
  [20:28:19.666]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:28:19.666]                   label = label, ...)
  [20:28:19.666]                 if (!future$lazy) 
  [20:28:19.666]                   future <- run(future)
  [20:28:19.666]                 invisible(future)
  [20:28:19.666]             }), .cleanup = FALSE, .init = FALSE)
  [20:28:19.666]         }
  [20:28:19.666]         options(...future.oldOptions)
  [20:28:19.666]     })
  [20:28:19.666]     if (is.na(TRUE)) {
  [20:28:19.666]     }
  [20:28:19.666]     else {
  [20:28:19.666]         sink(type = "output", split = FALSE)
  [20:28:19.666]         if (TRUE) {
  [20:28:19.666]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:28:19.666]         }
  [20:28:19.666]         else {
  [20:28:19.666]             ...future.result["stdout"] <- list(NULL)
  [20:28:19.666]         }
  [20:28:19.666]         close(...future.stdout)
  [20:28:19.666]         ...future.stdout <- NULL
  [20:28:19.666]     }
  [20:28:19.666]     ...future.result$conditions <- ...future.conditions
  [20:28:19.666]     ...future.result
  [20:28:19.666] }
  [20:28:19.685] MultisessionFuture started
  [20:28:19.686] result() for ClusterFuture ...
  [20:28:19.687] - Validating connection of MultisessionFuture
  [20:28:19.956] - class(result): FutureResult
  [20:28:19.963] result() for ClusterFuture ...
  [20:28:19.964] - result already collected: FutureResult
  [20:28:19.964] result() for ClusterFuture ... done
  [20:28:19.964] result() for ClusterFuture ... done
  [20:28:19.964] result() for ClusterFuture ...
  [20:28:19.965] - result already collected: FutureResult
  [20:28:19.965] result() for ClusterFuture ... done
  [20:28:19.965] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:28:19.966] plan(): nbrOfWorkers() = 2
  nbrOfWorkers: 2
  [20:28:19.967] plan(): Setting new future strategy stack:
  [20:28:19.968] List of future strategies:
  [20:28:19.968] 1. multisession:
  [20:28:19.968]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = "<function () ; max(1L, future::availableCores() - 1L)>", gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:28:19.968]    - tweaked: TRUE
  [20:28:19.968]    - call: plan(strategy, workers = allButOneCore)
  [20:28:19.989] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:28:19.989] multisession:
  [20:28:19.989] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = "<function () ; max(1L, future::availableCores() - 1L)>", gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:28:19.989] - tweaked: TRUE
  [20:28:19.989] - call: plan(strategy, workers = allButOneCore)
  [20:28:20.013] getGlobalsAndPackages() ...
  [20:28:20.013] Not searching for globals
  [20:28:20.014] - globals: [0] <none>
  [20:28:20.014] getGlobalsAndPackages() ... DONE
  [20:28:20.016] Packages needed by the future expression (n = 0): <none>
  [20:28:20.016] Packages needed by future strategies (n = 0): <none>
  [20:28:20.020] {
  [20:28:20.020]     {
  [20:28:20.020]         ...future.startTime <- Sys.time()
  [20:28:20.020]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:28:20.020]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:28:20.020]             future.globals.method = NULL, future.globals.onMissing = NULL, 
  [20:28:20.020]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:28:20.020]             future.resolve.recursive = NULL, width = 80L)
  [20:28:20.020]         {
  [20:28:20.020]             {
  [20:28:20.020]                 has_future <- requireNamespace("future", quietly = TRUE)
  [20:28:20.020]                 version <- if (has_future) 
  [20:28:20.020]                   packageVersion("future")
  [20:28:20.020]                 else NULL
  [20:28:20.020]                 if (!has_future || version < "1.8.0") {
  [20:28:20.020]                   info <- c(r_version = gsub("R version ", "", 
  [20:28:20.020]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:28:20.020]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:28:20.020]                     os = paste(Sys.info()[c("sysname", "release", 
  [20:28:20.020]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:28:20.020]                   info <- sprintf("%s: %s", names(info), info)
  [20:28:20.020]                   info <- paste(info, collapse = "; ")
  [20:28:20.020]                   if (!has_future) {
  [20:28:20.020]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:28:20.020]                       info)
  [20:28:20.020]                   }
  [20:28:20.020]                   else {
  [20:28:20.020]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:28:20.020]                       info, version)
  [20:28:20.020]                   }
  [20:28:20.020]                   stop(msg)
  [20:28:20.020]                 }
  [20:28:20.020]             }
  [20:28:20.020]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:28:20.020]         }
  [20:28:20.020]     }
  [20:28:20.020]     if (is.na(TRUE)) {
  [20:28:20.020]     }
  [20:28:20.020]     else {
  [20:28:20.020]         if (TRUE) {
  [20:28:20.020]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:28:20.020]         }
  [20:28:20.020]         else {
  [20:28:20.020]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:28:20.020]                 windows = "NUL", "/dev/null"), open = "w")
  [20:28:20.020]         }
  [20:28:20.020]         sink(...future.stdout, type = "output", split = FALSE)
  [20:28:20.020]         on.exit(if (!is.null(...future.stdout)) {
  [20:28:20.020]             sink(type = "output", split = FALSE)
  [20:28:20.020]             close(...future.stdout)
  [20:28:20.020]         }, add = TRUE)
  [20:28:20.020]     }
  [20:28:20.020]     ...future.frame <- sys.nframe()
  [20:28:20.020]     ...future.conditions <- list()
  [20:28:20.020]     ...future.result <- tryCatch({
  [20:28:20.020]         withCallingHandlers({
  [20:28:20.020]             ...future.value <- local(NA)
  [20:28:20.020]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:28:20.020]                 version = "1.8")
  [20:28:20.020]         }, condition = local({
  [20:28:20.020]             inherits <- base::inherits
  [20:28:20.020]             invokeRestart <- base::invokeRestart
  [20:28:20.020]             length <- base::length
  [20:28:20.020]             seq.int <- base::seq.int
  [20:28:20.020]             sys.calls <- base::sys.calls
  [20:28:20.020]             `[[` <- base::`[[`
  [20:28:20.020]             `+` <- base::`+`
  [20:28:20.020]             `<<-` <- base::`<<-`
  [20:28:20.020]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:28:20.020]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:28:20.020]                   3L)]
  [20:28:20.020]             }
  [20:28:20.020]             function(cond) {
  [20:28:20.020]                 if (inherits(cond, "error")) {
  [20:28:20.020]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:20.020]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:28:20.020]                     cond$call), timestamp = base::Sys.time(), 
  [20:28:20.020]                     signaled = 0L)
  [20:28:20.020]                   signalCondition(cond)
  [20:28:20.020]                 }
  [20:28:20.020]                 else if (inherits(cond, c("condition", "immediateCondition"
  [20:28:20.020]                 ))) {
  [20:28:20.020]                   signal <- TRUE && inherits(cond, "immediateCondition")
  [20:28:20.020]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:20.020]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:28:20.020]                   if (inherits(cond, "message")) {
  [20:28:20.020]                     if (!signal) 
  [20:28:20.020]                       invokeRestart("muffleMessage")
  [20:28:20.020]                   }
  [20:28:20.020]                   else if (inherits(cond, "warning")) {
  [20:28:20.020]                     if (!signal) 
  [20:28:20.020]                       invokeRestart("muffleWarning")
  [20:28:20.020]                   }
  [20:28:20.020]                   else {
  [20:28:20.020]                     if (!signal) {
  [20:28:20.020]                       restarts <- computeRestarts(cond)
  [20:28:20.020]                       for (restart in restarts) {
  [20:28:20.020]                         name <- restart$name
  [20:28:20.020]                         if (is.null(name)) 
  [20:28:20.020]                           next
  [20:28:20.020]                         if (!grepl("^muffle", name)) 
  [20:28:20.020]                           next
  [20:28:20.020]                         invokeRestart(restart)
  [20:28:20.020]                         break
  [20:28:20.020]                       }
  [20:28:20.020]                     }
  [20:28:20.020]                   }
  [20:28:20.020]                 }
  [20:28:20.020]             }
  [20:28:20.020]         }))
  [20:28:20.020]     }, error = function(ex) {
  [20:28:20.020]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:28:20.020]             version = "1.8"), class = "FutureResult")
  [20:28:20.020]     }, finally = {
  [20:28:20.020]         {
  [20:28:20.020]             NULL
  [20:28:20.020]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:28:20.020]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:28:20.020]                 globals = TRUE, persistent = FALSE, workers = function () 
  [20:28:20.020]                 max(1L, future::availableCores() - 1L), gc = FALSE, 
  [20:28:20.020]                 earlySignal = FALSE, label = NULL, ...) 
  [20:28:20.020]             {
  [20:28:20.020]                 if (substitute) 
  [20:28:20.020]                   expr <- substitute(expr)
  [20:28:20.020]                 if (is.function(workers)) 
  [20:28:20.020]                   workers <- workers()
  [20:28:20.020]                 workers <- as.integer(workers)
  [20:28:20.020]                 stop_if_not(length(workers) == 1, is.finite(workers), 
  [20:28:20.020]                   workers >= 1)
  [20:28:20.020]                 if (workers == 1L) {
  [20:28:20.020]                   return(sequential(expr, envir = envir, substitute = FALSE, 
  [20:28:20.020]                     lazy = TRUE, seed = seed, globals = globals, 
  [20:28:20.020]                     local = TRUE, label = label, ...))
  [20:28:20.020]                 }
  [20:28:20.020]                 workers <- ClusterRegistry("start", workers = workers)
  [20:28:20.020]                 future <- MultisessionFuture(expr = expr, envir = envir, 
  [20:28:20.020]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:28:20.020]                   globals = globals, persistent = persistent, 
  [20:28:20.020]                   workers = workers, gc = gc, earlySignal = earlySignal, 
  [20:28:20.020]                   label = label, ...)
  [20:28:20.020]                 if (!future$lazy) 
  [20:28:20.020]                   future <- run(future)
  [20:28:20.020]                 invisible(future)
  [20:28:20.020]             }), .cleanup = FALSE, .init = FALSE)
  [20:28:20.020]         }
  [20:28:20.020]         options(...future.oldOptions)
  [20:28:20.020]     })
  [20:28:20.020]     if (is.na(TRUE)) {
  [20:28:20.020]     }
  [20:28:20.020]     else {
  [20:28:20.020]         sink(type = "output", split = FALSE)
  [20:28:20.020]         if (TRUE) {
  [20:28:20.020]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:28:20.020]         }
  [20:28:20.020]         else {
  [20:28:20.020]             ...future.result["stdout"] <- list(NULL)
  [20:28:20.020]         }
  [20:28:20.020]         close(...future.stdout)
  [20:28:20.020]         ...future.stdout <- NULL
  [20:28:20.020]     }
  [20:28:20.020]     ...future.result$conditions <- ...future.conditions
  [20:28:20.020]     ...future.result
  [20:28:20.020] }
  [20:28:20.025] plan(): Setting new future strategy stack:
  [20:28:20.025] List of future strategies:
  [20:28:20.025] 1. sequential:
  [20:28:20.025]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [20:28:20.025]    - tweaked: FALSE
  [20:28:20.025]    - call: NULL
  [20:28:20.043] plan(): nbrOfWorkers() = 1
  [20:28:20.044] plan(): Setting new future strategy stack:
  [20:28:20.044] List of future strategies:
  [20:28:20.044] 1. multisession:
  [20:28:20.044]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = "<function () ; max(1L, future::availableCores() - 1L)>", gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  [20:28:20.044]    - tweaked: TRUE
  [20:28:20.044]    - call: plan(strategy, workers = allButOneCore)
  [20:28:20.049] plan(): nbrOfWorkers() = 1
  [20:28:20.050] SequentialFuture started (and completed)
  [20:28:20.051] plan(): plan_init() of 'tweaked', 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:28:20.051] plan(): nbrOfWorkers() = 1
  nbrOfWorkers: 1
  Type of future: multicore
  nbrOfWorkers: 2
  [20:28:20.053] plan(): Setting new future strategy stack:
  [20:28:20.054] List of future strategies:
  [20:28:20.054] 1. multicore:
  [20:28:20.054]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
  [20:28:20.054]    - tweaked: FALSE
  [20:28:20.054]    - call: plan(strategy)
  [20:28:20.055] plan(): nbrOfWorkers() = 2
  nbrOfWorkers: 2
  [20:28:20.075] plan(): Setting new future strategy stack:
  [20:28:20.075] List of future strategies:
  [20:28:20.075] 1. multicore:
  [20:28:20.075]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = "<function () ; max(1L, future::availableCores() - 1L); <bytecode: 0x560dd0e03a90>>", earlySignal = FALSE, label = NULL, ...)
  [20:28:20.075]    - tweaked: TRUE
  [20:28:20.075]    - call: plan(strategy, workers = allButOneCore)
  [20:28:20.077] plan(): nbrOfWorkers() = 1
  nbrOfWorkers: 1
  > 
  > 
  > message("Type of future: cluster")
  Type of future: cluster
  > workers <- rep("localhost", times = 2L)
  > plan(cluster, workers = workers)
  [20:28:20.079] plan(): Setting new future strategy stack:
  [20:28:20.079] List of future strategies:
  [20:28:20.079] 1. cluster:
  [20:28:20.079]    - 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, ...)
  [20:28:20.079]    - tweaked: TRUE
  [20:28:20.079]    - call: plan(cluster, workers = workers)
  [20:28:20.080] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:28:20.080] cluster:
  [20:28:20.080] - 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, ...)
  [20:28:20.080] - tweaked: TRUE
  [20:28:20.080] - call: plan(cluster, workers = workers)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.3132ba340b1.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.3132ba340b1.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.3132ba340b1.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31323ac8f98b.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31323ac8f98b.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31323ac8f98b.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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
  [20:28:36.623] getGlobalsAndPackages() ...
  [20:28:36.623] Not searching for globals
  [20:28:36.623] - globals: [0] <none>
  [20:28:36.624] getGlobalsAndPackages() ... DONE
  [20:28:36.625] Packages needed by the future expression (n = 0): <none>
  [20:28:36.625] Packages needed by future strategies (n = 0): <none>
  [20:28:36.629] {
  [20:28:36.629]     {
  [20:28:36.629]         ...future.startTime <- Sys.time()
  [20:28:36.629]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:28:36.629]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:28:36.629]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:28:36.629]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:28:36.629]             future.resolve.recursive = NULL, width = 80L)
  [20:28:36.629]         {
  [20:28:36.629]             {
  [20:28:36.629]                 has_future <- requireNamespace("future", quietly = TRUE)
  [20:28:36.629]                 version <- if (has_future) 
  [20:28:36.629]                   packageVersion("future")
  [20:28:36.629]                 else NULL
  [20:28:36.629]                 if (!has_future || version < "1.8.0") {
  [20:28:36.629]                   info <- c(r_version = gsub("R version ", "", 
  [20:28:36.629]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:28:36.629]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:28:36.629]                     os = paste(Sys.info()[c("sysname", "release", 
  [20:28:36.629]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:28:36.629]                   info <- sprintf("%s: %s", names(info), info)
  [20:28:36.629]                   info <- paste(info, collapse = "; ")
  [20:28:36.629]                   if (!has_future) {
  [20:28:36.629]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:28:36.629]                       info)
  [20:28:36.629]                   }
  [20:28:36.629]                   else {
  [20:28:36.629]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:28:36.629]                       info, version)
  [20:28:36.629]                   }
  [20:28:36.629]                   stop(msg)
  [20:28:36.629]                 }
  [20:28:36.629]             }
  [20:28:36.629]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:28:36.629]         }
  [20:28:36.629]     }
  [20:28:36.629]     if (is.na(TRUE)) {
  [20:28:36.629]     }
  [20:28:36.629]     else {
  [20:28:36.629]         if (TRUE) {
  [20:28:36.629]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:28:36.629]         }
  [20:28:36.629]         else {
  [20:28:36.629]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:28:36.629]                 windows = "NUL", "/dev/null"), open = "w")
  [20:28:36.629]         }
  [20:28:36.629]         sink(...future.stdout, type = "output", split = FALSE)
  [20:28:36.629]         on.exit(if (!is.null(...future.stdout)) {
  [20:28:36.629]             sink(type = "output", split = FALSE)
  [20:28:36.629]             close(...future.stdout)
  [20:28:36.629]         }, add = TRUE)
  [20:28:36.629]     }
  [20:28:36.629]     ...future.frame <- sys.nframe()
  [20:28:36.629]     ...future.conditions <- list()
  [20:28:36.629]     ...future.result <- tryCatch({
  [20:28:36.629]         withCallingHandlers({
  [20:28:36.629]             ...future.value <- local(NA)
  [20:28:36.629]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:28:36.629]                 version = "1.8")
  [20:28:36.629]         }, condition = local({
  [20:28:36.629]             inherits <- base::inherits
  [20:28:36.629]             invokeRestart <- base::invokeRestart
  [20:28:36.629]             length <- base::length
  [20:28:36.629]             seq.int <- base::seq.int
  [20:28:36.629]             sys.calls <- base::sys.calls
  [20:28:36.629]             `[[` <- base::`[[`
  [20:28:36.629]             `+` <- base::`+`
  [20:28:36.629]             `<<-` <- base::`<<-`
  [20:28:36.629]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:28:36.629]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:28:36.629]                   3L)]
  [20:28:36.629]             }
  [20:28:36.629]             function(cond) {
  [20:28:36.629]                 if (inherits(cond, "error")) {
  [20:28:36.629]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:36.629]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:28:36.629]                     cond$call), timestamp = base::Sys.time(), 
  [20:28:36.629]                     signaled = 0L)
  [20:28:36.629]                   signalCondition(cond)
  [20:28:36.629]                 }
  [20:28:36.629]                 else if (inherits(cond, "condition")) {
  [20:28:36.629]                   signal <- FALSE && inherits(cond, character(0))
  [20:28:36.629]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:36.629]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:28:36.629]                   if (inherits(cond, "message")) {
  [20:28:36.629]                     if (!signal) 
  [20:28:36.629]                       invokeRestart("muffleMessage")
  [20:28:36.629]                   }
  [20:28:36.629]                   else if (inherits(cond, "warning")) {
  [20:28:36.629]                     if (!signal) 
  [20:28:36.629]                       invokeRestart("muffleWarning")
  [20:28:36.629]                   }
  [20:28:36.629]                   else {
  [20:28:36.629]                     if (!signal) {
  [20:28:36.629]                       restarts <- computeRestarts(cond)
  [20:28:36.629]                       for (restart in restarts) {
  [20:28:36.629]                         name <- restart$name
  [20:28:36.629]                         if (is.null(name)) 
  [20:28:36.629]                           next
  [20:28:36.629]                         if (!grepl("^muffle", name)) 
  [20:28:36.629]                           next
  [20:28:36.629]                         invokeRestart(restart)
  [20:28:36.629]                         break
  [20:28:36.629]                       }
  [20:28:36.629]                     }
  [20:28:36.629]                   }
  [20:28:36.629]                 }
  [20:28:36.629]             }
  [20:28:36.629]         }))
  [20:28:36.629]     }, error = function(ex) {
  [20:28:36.629]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:28:36.629]             version = "1.8"), class = "FutureResult")
  [20:28:36.629]     }, finally = {
  [20:28:36.629]         {
  [20:28:36.629]             NULL
  [20:28:36.629]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:28:36.629]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:28:36.629]                 globals = TRUE, persistent = FALSE, workers = c("localhost", 
  [20:28:36.629]                 "localhost"), user = NULL, revtunnel = TRUE, 
  [20:28:36.629]                 homogeneous = TRUE, gc = FALSE, earlySignal = FALSE, 
  [20:28:36.629]                 label = NULL, ...) 
  [20:28:36.629]             {
  [20:28:36.629]                 if (substitute) 
  [20:28:36.629]                   expr <- substitute(expr)
  [20:28:36.629]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:28:36.629]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:28:36.629]                   globals = globals, persistent = persistent, 
  [20:28:36.629]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:28:36.629]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:28:36.629]                   label = label, ...)
  [20:28:36.629]                 if (!future$lazy) 
  [20:28:36.629]                   future <- run(future)
  [20:28:36.629]                 invisible(future)
  [20:28:36.629]             }), .cleanup = FALSE, .init = FALSE)
  [20:28:36.629]         }
  [20:28:36.629]         options(...future.oldOptions)
  [20:28:36.629]     })
  [20:28:36.629]     if (is.na(TRUE)) {
  [20:28:36.629]     }
  [20:28:36.629]     else {
  [20:28:36.629]         sink(type = "output", split = FALSE)
  [20:28:36.629]         if (TRUE) {
  [20:28:36.629]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:28:36.629]         }
  [20:28:36.629]         else {
  [20:28:36.629]             ...future.result["stdout"] <- list(NULL)
  [20:28:36.629]         }
  [20:28:36.629]         close(...future.stdout)
  [20:28:36.629]         ...future.stdout <- NULL
  [20:28:36.629]     }
  [20:28:36.629]     ...future.result$conditions <- ...future.conditions
  [20:28:36.629]     ...future.result
  [20:28:36.629] }
  [20:28:36.642] ClusterFuture started
  [20:28:36.643] result() for ClusterFuture ...
  [20:28:36.643] - Validating connection of ClusterFuture
  [20:28:36.826] - class(result): FutureResult
  [20:28:36.827] result() for ClusterFuture ...
  [20:28:36.827] - result already collected: FutureResult
  [20:28:36.827] result() for ClusterFuture ... done
  [20:28:36.827] result() for ClusterFuture ... done
  [20:28:36.828] result() for ClusterFuture ...
  [20:28:36.828] - result already collected: FutureResult
  [20:28:36.828] result() for ClusterFuture ... done
  [20:28:36.829] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:28:36.829] plan(): nbrOfWorkers() = 2
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 2
  > stopifnot(n == length(workers))
  > plan(cluster, workers = allButOneWorker)
  [20:28:36.830] plan(): Setting new future strategy stack:
  [20:28:36.830] List of future strategies:
  [20:28:36.830] 1. cluster:
  [20:28:36.830]    - 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, ...)
  [20:28:36.830]    - tweaked: TRUE
  [20:28:36.830]    - call: plan(cluster, workers = allButOneWorker)
  [20:28:36.835] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:28:36.836] cluster:
  [20:28:36.836] - 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, ...)
  [20:28:36.836] - tweaked: TRUE
  [20:28:36.836] - call: plan(cluster, workers = allButOneWorker)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313239ad4804.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313239ad4804.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313239ad4804.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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
  [20:28:44.547] getGlobalsAndPackages() ...
  [20:28:44.548] Not searching for globals
  [20:28:44.548] - globals: [0] <none>
  [20:28:44.549] getGlobalsAndPackages() ... DONE
  [20:28:44.550] Packages needed by the future expression (n = 0): <none>
  [20:28:44.551] Packages needed by future strategies (n = 0): <none>
  [20:28:44.555] {
  [20:28:44.555]     {
  [20:28:44.555]         ...future.startTime <- Sys.time()
  [20:28:44.555]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:28:44.555]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:28:44.555]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:28:44.555]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:28:44.555]             future.resolve.recursive = NULL, width = 80L)
  [20:28:44.555]         {
  [20:28:44.555]             {
  [20:28:44.555]                 has_future <- requireNamespace("future", quietly = TRUE)
  [20:28:44.555]                 version <- if (has_future) 
  [20:28:44.555]                   packageVersion("future")
  [20:28:44.555]                 else NULL
  [20:28:44.555]                 if (!has_future || version < "1.8.0") {
  [20:28:44.555]                   info <- c(r_version = gsub("R version ", "", 
  [20:28:44.555]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:28:44.555]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:28:44.555]                     os = paste(Sys.info()[c("sysname", "release", 
  [20:28:44.555]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:28:44.555]                   info <- sprintf("%s: %s", names(info), info)
  [20:28:44.555]                   info <- paste(info, collapse = "; ")
  [20:28:44.555]                   if (!has_future) {
  [20:28:44.555]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:28:44.555]                       info)
  [20:28:44.555]                   }
  [20:28:44.555]                   else {
  [20:28:44.555]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:28:44.555]                       info, version)
  [20:28:44.555]                   }
  [20:28:44.555]                   stop(msg)
  [20:28:44.555]                 }
  [20:28:44.555]             }
  [20:28:44.555]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:28:44.555]         }
  [20:28:44.555]     }
  [20:28:44.555]     if (is.na(TRUE)) {
  [20:28:44.555]     }
  [20:28:44.555]     else {
  [20:28:44.555]         if (TRUE) {
  [20:28:44.555]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:28:44.555]         }
  [20:28:44.555]         else {
  [20:28:44.555]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:28:44.555]                 windows = "NUL", "/dev/null"), open = "w")
  [20:28:44.555]         }
  [20:28:44.555]         sink(...future.stdout, type = "output", split = FALSE)
  [20:28:44.555]         on.exit(if (!is.null(...future.stdout)) {
  [20:28:44.555]             sink(type = "output", split = FALSE)
  [20:28:44.555]             close(...future.stdout)
  [20:28:44.555]         }, add = TRUE)
  [20:28:44.555]     }
  [20:28:44.555]     ...future.frame <- sys.nframe()
  [20:28:44.555]     ...future.conditions <- list()
  [20:28:44.555]     ...future.result <- tryCatch({
  [20:28:44.555]         withCallingHandlers({
  [20:28:44.555]             ...future.value <- local(NA)
  [20:28:44.555]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:28:44.555]                 version = "1.8")
  [20:28:44.555]         }, condition = local({
  [20:28:44.555]             inherits <- base::inherits
  [20:28:44.555]             invokeRestart <- base::invokeRestart
  [20:28:44.555]             length <- base::length
  [20:28:44.555]             seq.int <- base::seq.int
  [20:28:44.555]             sys.calls <- base::sys.calls
  [20:28:44.555]             `[[` <- base::`[[`
  [20:28:44.555]             `+` <- base::`+`
  [20:28:44.555]             `<<-` <- base::`<<-`
  [20:28:44.555]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:28:44.555]                 calls[seq.int(from = from + 12L, to = length(calls) - 
  [20:28:44.555]                   3L)]
  [20:28:44.555]             }
  [20:28:44.555]             function(cond) {
  [20:28:44.555]                 if (inherits(cond, "error")) {
  [20:28:44.555]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:44.555]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:28:44.555]                     cond$call), timestamp = base::Sys.time(), 
  [20:28:44.555]                     signaled = 0L)
  [20:28:44.555]                   signalCondition(cond)
  [20:28:44.555]                 }
  [20:28:44.555]                 else if (inherits(cond, "condition")) {
  [20:28:44.555]                   signal <- FALSE && inherits(cond, character(0))
  [20:28:44.555]                   ...future.conditions[[length(...future.conditions) + 
  [20:28:44.555]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:28:44.555]                   if (inherits(cond, "message")) {
  [20:28:44.555]                     if (!signal) 
  [20:28:44.555]                       invokeRestart("muffleMessage")
  [20:28:44.555]                   }
  [20:28:44.555]                   else if (inherits(cond, "warning")) {
  [20:28:44.555]                     if (!signal) 
  [20:28:44.555]                       invokeRestart("muffleWarning")
  [20:28:44.555]                   }
  [20:28:44.555]                   else {
  [20:28:44.555]                     if (!signal) {
  [20:28:44.555]                       restarts <- computeRestarts(cond)
  [20:28:44.555]                       for (restart in restarts) {
  [20:28:44.555]                         name <- restart$name
  [20:28:44.555]                         if (is.null(name)) 
  [20:28:44.555]                           next
  [20:28:44.555]                         if (!grepl("^muffle", name)) 
  [20:28:44.555]                           next
  [20:28:44.555]                         invokeRestart(restart)
  [20:28:44.555]                         break
  [20:28:44.555]                       }
  [20:28:44.555]                     }
  [20:28:44.555]                   }
  [20:28:44.555]                 }
  [20:28:44.555]             }
  [20:28:44.555]         }))
  [20:28:44.555]     }, error = function(ex) {
  [20:28:44.555]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:28:44.555]             version = "1.8"), class = "FutureResult")
  [20:28:44.555]     }, finally = {
  [20:28:44.555]         {
  [20:28:44.555]             NULL
  [20:28:44.555]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:28:44.555]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:28:44.555]                 globals = TRUE, persistent = FALSE, workers = function () 
  [20:28:44.555]                 {
  [20:28:44.555]                   w <- future::availableWorkers()
  [20:28:44.555]                   if (length(w) > 1) 
  [20:28:44.555]                     w[-1]
  [20:28:44.555]                   else w
  [20:28:44.555]                 }, user = NULL, revtunnel = TRUE, homogeneous = TRUE, 
  [20:28:44.555]                 gc = FALSE, earlySignal = FALSE, label = NULL, 
  [20:28:44.555]                 ...) 
  [20:28:44.555]             {
  [20:28:44.555]                 if (substitute) 
  [20:28:44.555]                   expr <- substitute(expr)
  [20:28:44.555]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:28:44.555]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:28:44.555]                   globals = globals, persistent = persistent, 
  [20:28:44.555]                   workers = workers, user = user, revtunnel = revtunnel, 
  [20:28:44.555]                   homogeneous = homogeneous, gc = gc, earlySignal = earlySignal, 
  [20:28:44.555]                   label = label, ...)
  [20:28:44.555]                 if (!future$lazy) 
  [20:28:44.555]                   future <- run(future)
  [20:28:44.555]                 invisible(future)
  [20:28:44.555]             }), .cleanup = FALSE, .init = FALSE)
  [20:28:44.555]         }
  [20:28:44.555]         options(...future.oldOptions)
  [20:28:44.555]     })
  [20:28:44.555]     if (is.na(TRUE)) {
  [20:28:44.555]     }
  [20:28:44.555]     else {
  [20:28:44.555]         sink(type = "output", split = FALSE)
  [20:28:44.555]         if (TRUE) {
  [20:28:44.555]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:28:44.555]         }
  [20:28:44.555]         else {
  [20:28:44.555]             ...future.result["stdout"] <- list(NULL)
  [20:28:44.555]         }
  [20:28:44.555]         close(...future.stdout)
  [20:28:44.555]         ...future.stdout <- NULL
  [20:28:44.555]     }
  [20:28:44.555]     ...future.result$conditions <- ...future.conditions
  [20:28:44.555]     ...future.result
  [20:28:44.555] }
  [20:28:44.568] ClusterFuture started
  [20:28:44.569] result() for ClusterFuture ...
  [20:28:44.569] - Validating connection of ClusterFuture
  [20:28:44.790] - class(result): FutureResult
  [20:28:44.791] result() for ClusterFuture ...
  [20:28:44.791] - result already collected: FutureResult
  [20:28:44.791] result() for ClusterFuture ... done
  [20:28:44.792] result() for ClusterFuture ... done
  [20:28:44.792] result() for ClusterFuture ...
  [20:28:44.792] - result already collected: FutureResult
  [20:28:44.793] result() for ClusterFuture ... done
  [20:28:44.793] plan(): plan_init() of 'tweaked', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:28:44.800] 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)
  [20:28:44.803] plan(): Setting new future strategy stack:
  [20:28:44.803] List of future strategies:
  [20:28:44.803] 1. remote:
  [20:28:44.803]    - 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, ...)
  [20:28:44.803]    - tweaked: TRUE
  [20:28:44.803]    - call: plan(remote, workers = workers)
  [20:28:44.814] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:28:44.815] remote:
  [20:28:44.815] - 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, ...)
  [20:28:44.815] - tweaked: TRUE
  [20:28:44.815] - call: plan(remote, workers = workers)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326edbb73d.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326edbb73d.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326edbb73d.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=11986 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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31322756787a.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31322756787a.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #2 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31322756787a.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=11986 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
  [20:29:00.391] getGlobalsAndPackages() ...
  [20:29:00.391] Not searching for globals
  [20:29:00.392] - globals: [0] <none>
  [20:29:00.392] getGlobalsAndPackages() ... DONE
  [20:29:00.394] Packages needed by the future expression (n = 0): <none>
  [20:29:00.394] Packages needed by future strategies (n = 0): <none>
  [20:29:00.399] {
  [20:29:00.399]     {
  [20:29:00.399]         ...future.startTime <- Sys.time()
  [20:29:00.399]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:29:00.399]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:29:00.399]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:29:00.399]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:29:00.399]             future.resolve.recursive = NULL, width = 80L)
  [20:29:00.399]         {
  [20:29:00.399]             {
  [20:29:00.399]                 has_future <- requireNamespace("future", quietly = TRUE)
  [20:29:00.399]                 version <- if (has_future) 
  [20:29:00.399]                   packageVersion("future")
  [20:29:00.399]                 else NULL
  [20:29:00.399]                 if (!has_future || version < "1.8.0") {
  [20:29:00.399]                   info <- c(r_version = gsub("R version ", "", 
  [20:29:00.399]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:29:00.399]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:29:00.399]                     os = paste(Sys.info()[c("sysname", "release", 
  [20:29:00.399]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:29:00.399]                   info <- sprintf("%s: %s", names(info), info)
  [20:29:00.399]                   info <- paste(info, collapse = "; ")
  [20:29:00.399]                   if (!has_future) {
  [20:29:00.399]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:29:00.399]                       info)
  [20:29:00.399]                   }
  [20:29:00.399]                   else {
  [20:29:00.399]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:29:00.399]                       info, version)
  [20:29:00.399]                   }
  [20:29:00.399]                   stop(msg)
  [20:29:00.399]                 }
  [20:29:00.399]             }
  [20:29:00.399]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:29:00.399]         }
  [20:29:00.399]     }
  [20:29:00.399]     if (is.na(TRUE)) {
  [20:29:00.399]     }
  [20:29:00.399]     else {
  [20:29:00.399]         if (TRUE) {
  [20:29:00.399]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:29:00.399]         }
  [20:29:00.399]         else {
  [20:29:00.399]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:29:00.399]                 windows = "NUL", "/dev/null"), open = "w")
  [20:29:00.399]         }
  [20:29:00.399]         sink(...future.stdout, type = "output", split = FALSE)
  [20:29:00.399]         on.exit(if (!is.null(...future.stdout)) {
  [20:29:00.399]             sink(type = "output", split = FALSE)
  [20:29:00.399]             close(...future.stdout)
  [20:29:00.399]         }, add = TRUE)
  [20:29:00.399]     }
  [20:29:00.399]     ...future.frame <- sys.nframe()
  [20:29:00.399]     ...future.conditions <- list()
  [20:29:00.399]     ...future.result <- tryCatch({
  [20:29:00.399]         withCallingHandlers({
  [20:29:00.399]             ...future.value <- NA
  [20:29:00.399]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:29:00.399]                 version = "1.8")
  [20:29:00.399]         }, condition = local({
  [20:29:00.399]             inherits <- base::inherits
  [20:29:00.399]             invokeRestart <- base::invokeRestart
  [20:29:00.399]             length <- base::length
  [20:29:00.399]             seq.int <- base::seq.int
  [20:29:00.399]             sys.calls <- base::sys.calls
  [20:29:00.399]             `[[` <- base::`[[`
  [20:29:00.399]             `+` <- base::`+`
  [20:29:00.399]             `<<-` <- base::`<<-`
  [20:29:00.399]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:29:00.399]                 calls[seq.int(from = from + 6L, to = length(calls) - 
  [20:29:00.399]                   3L)]
  [20:29:00.399]             }
  [20:29:00.399]             function(cond) {
  [20:29:00.399]                 if (inherits(cond, "error")) {
  [20:29:00.399]                   ...future.conditions[[length(...future.conditions) + 
  [20:29:00.399]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:29:00.399]                     cond$call), timestamp = base::Sys.time(), 
  [20:29:00.399]                     signaled = 0L)
  [20:29:00.399]                   signalCondition(cond)
  [20:29:00.399]                 }
  [20:29:00.399]                 else if (inherits(cond, "condition")) {
  [20:29:00.399]                   signal <- FALSE && inherits(cond, character(0))
  [20:29:00.399]                   ...future.conditions[[length(...future.conditions) + 
  [20:29:00.399]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:29:00.399]                   if (inherits(cond, "message")) {
  [20:29:00.399]                     if (!signal) 
  [20:29:00.399]                       invokeRestart("muffleMessage")
  [20:29:00.399]                   }
  [20:29:00.399]                   else if (inherits(cond, "warning")) {
  [20:29:00.399]                     if (!signal) 
  [20:29:00.399]                       invokeRestart("muffleWarning")
  [20:29:00.399]                   }
  [20:29:00.399]                   else {
  [20:29:00.399]                     if (!signal) {
  [20:29:00.399]                       restarts <- computeRestarts(cond)
  [20:29:00.399]                       for (restart in restarts) {
  [20:29:00.399]                         name <- restart$name
  [20:29:00.399]                         if (is.null(name)) 
  [20:29:00.399]                           next
  [20:29:00.399]                         if (!grepl("^muffle", name)) 
  [20:29:00.399]                           next
  [20:29:00.399]                         invokeRestart(restart)
  [20:29:00.399]                         break
  [20:29:00.399]                       }
  [20:29:00.399]                     }
  [20:29:00.399]                   }
  [20:29:00.399]                 }
  [20:29:00.399]             }
  [20:29:00.399]         }))
  [20:29:00.399]     }, error = function(ex) {
  [20:29:00.399]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:29:00.399]             version = "1.8"), class = "FutureResult")
  [20:29:00.399]     }, finally = {
  [20:29:00.399]         {
  [20:29:00.399]             NULL
  [20:29:00.399]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:29:00.399]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:29:00.399]                 globals = TRUE, persistent = TRUE, workers = c("localhost", 
  [20:29:00.399]                 "localhost"), user = NULL, revtunnel = TRUE, 
  [20:29:00.399]                 gc = FALSE, earlySignal = FALSE, myip = NULL, 
  [20:29:00.399]                 label = NULL, ...) 
  [20:29:00.399]             {
  [20:29:00.399]                 if (substitute) 
  [20:29:00.399]                   expr <- substitute(expr)
  [20:29:00.399]                 if (is.function(workers)) 
  [20:29:00.399]                   workers <- workers()
  [20:29:00.399]                 stop_if_not(length(workers) >= 1L, !anyNA(workers))
  [20:29:00.399]                 if (is.character(workers)) {
  [20:29:00.399]                   homogeneous <- FALSE
  [20:29:00.399]                   if (all(workers %in% c("localhost", "127.0.0.1"))) {
  [20:29:00.399]                     homogeneous <- TRUE
  [20:29:00.399]                     revtunnel <- FALSE
  [20:29:00.399]                     myip <- "127.0.0.1"
  [20:29:00.399]                   }
  [20:29:00.399]                   else {
  [20:29:00.399]                     if (revtunnel) {
  [20:29:00.399]                       if (is.null(myip)) 
  [20:29:00.399]                         myip <- "127.0.0.1"
  [20:29:00.399]                     }
  [20:29:00.399]                     else if (is.null(myip)) {
  [20:29:00.399]                       myip <- "<external>"
  [20:29:00.399]                     }
  [20:29:00.399]                   }
  [20:29:00.399]                   stop_if_not(length(myip) == 1, is.character(myip), 
  [20:29:00.399]                     !is.na(myip))
  [20:29:00.399]                   if (myip == "<external>") {
  [20:29:00.399]                     myip <- myExternalIP()
  [20:29:00.399]                   }
  [20:29:00.399]                   else if (myip == "<internal>") {
  [20:29:00.399]                     myip <- myInternalIP()
  [20:29:00.399]                   }
  [20:29:00.399]                 }
  [20:29:00.399]                 else if (!inherits(workers, "cluster")) {
  [20:29:00.399]                   stop("Argument 'workers' is not of class 'cluster': ", 
  [20:29:00.399]                     class(workers)[1])
  [20:29:00.399]                 }
  [20:29:00.399]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:29:00.399]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:29:00.399]                   globals = globals, persistent = persistent, 
  [20:29:00.399]                   workers = workers, user = user, master = myip, 
  [20:29:00.399]                   revtunnel = revtunnel, homogeneous = homogeneous, 
  [20:29:00.399]                   gc = gc, earlySignal = earlySignal, label = label, 
  [20:29:00.399]                   ...)
  [20:29:00.399]                 if (!future$lazy) 
  [20:29:00.399]                   future <- run(future)
  [20:29:00.399]                 invisible(future)
  [20:29:00.399]             }), .cleanup = FALSE, .init = FALSE)
  [20:29:00.399]         }
  [20:29:00.399]         options(...future.oldOptions)
  [20:29:00.399]     })
  [20:29:00.399]     if (is.na(TRUE)) {
  [20:29:00.399]     }
  [20:29:00.399]     else {
  [20:29:00.399]         sink(type = "output", split = FALSE)
  [20:29:00.399]         if (TRUE) {
  [20:29:00.399]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:29:00.399]         }
  [20:29:00.399]         else {
  [20:29:00.399]             ...future.result["stdout"] <- list(NULL)
  [20:29:00.399]         }
  [20:29:00.399]         close(...future.stdout)
  [20:29:00.399]         ...future.stdout <- NULL
  [20:29:00.399]     }
  [20:29:00.399]     ...future.result$conditions <- ...future.conditions
  [20:29:00.399]     ...future.result
  [20:29:00.399] }
  [20:29:00.411] ClusterFuture started
  [20:29:00.412] result() for ClusterFuture ...
  [20:29:00.412] - Validating connection of ClusterFuture
  [20:29:00.528] - class(result): FutureResult
  [20:29:00.529] result() for ClusterFuture ...
  [20:29:00.529] - result already collected: FutureResult
  [20:29:00.529] result() for ClusterFuture ... done
  [20:29:00.529] result() for ClusterFuture ... done
  [20:29:00.530] result() for ClusterFuture ...
  [20:29:00.530] - result already collected: FutureResult
  [20:29:00.530] result() for ClusterFuture ... done
  [20:29:00.531] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:29:00.531] plan(): nbrOfWorkers() = 2
  > n <- nbrOfWorkers()
  > message(sprintf("nbrOfWorkers: %d", n))
  nbrOfWorkers: 2
  > stopifnot(n == length(workers))
  > plan(remote, workers = allButOneWorker)
  [20:29:00.532] plan(): Setting new future strategy stack:
  [20:29:00.532] List of future strategies:
  [20:29:00.532] 1. remote:
  [20:29:00.532]    - 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, ...)
  [20:29:00.532]    - tweaked: TRUE
  [20:29:00.532]    - call: plan(remote, workers = allButOneWorker)
  [20:29:00.538] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ...
  [20:29:00.539] remote:
  [20:29:00.539] - 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, ...)
  [20:29:00.539] - tweaked: TRUE
  [20:29:00.539] - call: plan(remote, workers = allButOneWorker)
  [local output] Workers: [n = 1] 'localhost'
  [local output] Base port: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326b982c1e.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326b982c1e.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.31326b982c1e.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=127.0.0.1 PORT=11986 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
  [20:29:09.712] getGlobalsAndPackages() ...
  [20:29:09.712] Not searching for globals
  [20:29:09.713] - globals: [0] <none>
  [20:29:09.713] getGlobalsAndPackages() ... DONE
  [20:29:09.714] Packages needed by the future expression (n = 0): <none>
  [20:29:09.715] Packages needed by future strategies (n = 0): <none>
  [20:29:09.734] {
  [20:29:09.734]     {
  [20:29:09.734]         ...future.startTime <- Sys.time()
  [20:29:09.734]         ...future.oldOptions <- options(future.startup.script = FALSE, 
  [20:29:09.734]             future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
  [20:29:09.734]             future.globals.method = NULL, future.globals.onMissing = "ignore", 
  [20:29:09.734]             future.globals.onReference = NULL, future.globals.resolve = NULL, 
  [20:29:09.734]             future.resolve.recursive = NULL, width = 80L)
  [20:29:09.734]         {
  [20:29:09.734]             {
  [20:29:09.734]                 has_future <- requireNamespace("future", quietly = TRUE)
  [20:29:09.734]                 version <- if (has_future) 
  [20:29:09.734]                   packageVersion("future")
  [20:29:09.734]                 else NULL
  [20:29:09.734]                 if (!has_future || version < "1.8.0") {
  [20:29:09.734]                   info <- c(r_version = gsub("R version ", "", 
  [20:29:09.734]                     R.version$version.string), platform = sprintf("%s (%s-bit)", 
  [20:29:09.734]                     R.version$platform, 8 * .Machine$sizeof.pointer), 
  [20:29:09.734]                     os = paste(Sys.info()[c("sysname", "release", 
  [20:29:09.734]                       "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
  [20:29:09.734]                   info <- sprintf("%s: %s", names(info), info)
  [20:29:09.734]                   info <- paste(info, collapse = "; ")
  [20:29:09.734]                   if (!has_future) {
  [20:29:09.734]                     msg <- sprintf("Package 'future' is not installed on worker (%s)", 
  [20:29:09.734]                       info)
  [20:29:09.734]                   }
  [20:29:09.734]                   else {
  [20:29:09.734]                     msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
  [20:29:09.734]                       info, version)
  [20:29:09.734]                   }
  [20:29:09.734]                   stop(msg)
  [20:29:09.734]                 }
  [20:29:09.734]             }
  [20:29:09.734]             future::plan("default", .cleanup = FALSE, .init = FALSE)
  [20:29:09.734]         }
  [20:29:09.734]     }
  [20:29:09.734]     if (is.na(TRUE)) {
  [20:29:09.734]     }
  [20:29:09.734]     else {
  [20:29:09.734]         if (TRUE) {
  [20:29:09.734]             ...future.stdout <- rawConnection(raw(0L), open = "w")
  [20:29:09.734]         }
  [20:29:09.734]         else {
  [20:29:09.734]             ...future.stdout <- file(switch(.Platform$OS.type, 
  [20:29:09.734]                 windows = "NUL", "/dev/null"), open = "w")
  [20:29:09.734]         }
  [20:29:09.734]         sink(...future.stdout, type = "output", split = FALSE)
  [20:29:09.734]         on.exit(if (!is.null(...future.stdout)) {
  [20:29:09.734]             sink(type = "output", split = FALSE)
  [20:29:09.734]             close(...future.stdout)
  [20:29:09.734]         }, add = TRUE)
  [20:29:09.734]     }
  [20:29:09.734]     ...future.frame <- sys.nframe()
  [20:29:09.734]     ...future.conditions <- list()
  [20:29:09.734]     ...future.result <- tryCatch({
  [20:29:09.734]         withCallingHandlers({
  [20:29:09.734]             ...future.value <- NA
  [20:29:09.734]             future::FutureResult(value = ...future.value, started = ...future.startTime, 
  [20:29:09.734]                 version = "1.8")
  [20:29:09.734]         }, condition = local({
  [20:29:09.734]             inherits <- base::inherits
  [20:29:09.734]             invokeRestart <- base::invokeRestart
  [20:29:09.734]             length <- base::length
  [20:29:09.734]             seq.int <- base::seq.int
  [20:29:09.734]             sys.calls <- base::sys.calls
  [20:29:09.734]             `[[` <- base::`[[`
  [20:29:09.734]             `+` <- base::`+`
  [20:29:09.734]             `<<-` <- base::`<<-`
  [20:29:09.734]             sysCalls <- function(calls = sys.calls(), from = 1L) {
  [20:29:09.734]                 calls[seq.int(from = from + 6L, to = length(calls) - 
  [20:29:09.734]                   3L)]
  [20:29:09.734]             }
  [20:29:09.734]             function(cond) {
  [20:29:09.734]                 if (inherits(cond, "error")) {
  [20:29:09.734]                   ...future.conditions[[length(...future.conditions) + 
  [20:29:09.734]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
  [20:29:09.734]                     cond$call), timestamp = base::Sys.time(), 
  [20:29:09.734]                     signaled = 0L)
  [20:29:09.734]                   signalCondition(cond)
  [20:29:09.734]                 }
  [20:29:09.734]                 else if (inherits(cond, "condition")) {
  [20:29:09.734]                   signal <- FALSE && inherits(cond, character(0))
  [20:29:09.734]                   ...future.conditions[[length(...future.conditions) + 
  [20:29:09.734]                     1L]] <<- list(condition = cond, signaled = as.integer(signal))
  [20:29:09.734]                   if (inherits(cond, "message")) {
  [20:29:09.734]                     if (!signal) 
  [20:29:09.734]                       invokeRestart("muffleMessage")
  [20:29:09.734]                   }
  [20:29:09.734]                   else if (inherits(cond, "warning")) {
  [20:29:09.734]                     if (!signal) 
  [20:29:09.734]                       invokeRestart("muffleWarning")
  [20:29:09.734]                   }
  [20:29:09.734]                   else {
  [20:29:09.734]                     if (!signal) {
  [20:29:09.734]                       restarts <- computeRestarts(cond)
  [20:29:09.734]                       for (restart in restarts) {
  [20:29:09.734]                         name <- restart$name
  [20:29:09.734]                         if (is.null(name)) 
  [20:29:09.734]                           next
  [20:29:09.734]                         if (!grepl("^muffle", name)) 
  [20:29:09.734]                           next
  [20:29:09.734]                         invokeRestart(restart)
  [20:29:09.734]                         break
  [20:29:09.734]                       }
  [20:29:09.734]                     }
  [20:29:09.734]                   }
  [20:29:09.734]                 }
  [20:29:09.734]             }
  [20:29:09.734]         }))
  [20:29:09.734]     }, error = function(ex) {
  [20:29:09.734]         structure(list(value = NULL, conditions = ...future.conditions, 
  [20:29:09.734]             version = "1.8"), class = "FutureResult")
  [20:29:09.734]     }, finally = {
  [20:29:09.734]         {
  [20:29:09.734]             NULL
  [20:29:09.734]             future::plan(list(function (expr, envir = parent.frame(), 
  [20:29:09.734]                 substitute = TRUE, lazy = FALSE, seed = NULL, 
  [20:29:09.734]                 globals = TRUE, persistent = TRUE, workers = function () 
  [20:29:09.734]                 {
  [20:29:09.734]                   w <- future::availableWorkers()
  [20:29:09.734]                   if (length(w) > 1) 
  [20:29:09.734]                     w[-1]
  [20:29:09.734]                   else w
  [20:29:09.734]                 }, user = NULL, revtunnel = TRUE, gc = FALSE, 
  [20:29:09.734]                 earlySignal = FALSE, myip = NULL, label = NULL, 
  [20:29:09.734]                 ...) 
  [20:29:09.734]             {
  [20:29:09.734]                 if (substitute) 
  [20:29:09.734]                   expr <- substitute(expr)
  [20:29:09.734]                 if (is.function(workers)) 
  [20:29:09.734]                   workers <- workers()
  [20:29:09.734]                 stop_if_not(length(workers) >= 1L, !anyNA(workers))
  [20:29:09.734]                 if (is.character(workers)) {
  [20:29:09.734]                   homogeneous <- FALSE
  [20:29:09.734]                   if (all(workers %in% c("localhost", "127.0.0.1"))) {
  [20:29:09.734]                     homogeneous <- TRUE
  [20:29:09.734]                     revtunnel <- FALSE
  [20:29:09.734]                     myip <- "127.0.0.1"
  [20:29:09.734]                   }
  [20:29:09.734]                   else {
  [20:29:09.734]                     if (revtunnel) {
  [20:29:09.734]                       if (is.null(myip)) 
  [20:29:09.734]                         myip <- "127.0.0.1"
  [20:29:09.734]                     }
  [20:29:09.734]                     else if (is.null(myip)) {
  [20:29:09.734]                       myip <- "<external>"
  [20:29:09.734]                     }
  [20:29:09.734]                   }
  [20:29:09.734]                   stop_if_not(length(myip) == 1, is.character(myip), 
  [20:29:09.734]                     !is.na(myip))
  [20:29:09.734]                   if (myip == "<external>") {
  [20:29:09.734]                     myip <- myExternalIP()
  [20:29:09.734]                   }
  [20:29:09.734]                   else if (myip == "<internal>") {
  [20:29:09.734]                     myip <- myInternalIP()
  [20:29:09.734]                   }
  [20:29:09.734]                 }
  [20:29:09.734]                 else if (!inherits(workers, "cluster")) {
  [20:29:09.734]                   stop("Argument 'workers' is not of class 'cluster': ", 
  [20:29:09.734]                     class(workers)[1])
  [20:29:09.734]                 }
  [20:29:09.734]                 future <- ClusterFuture(expr = expr, envir = envir, 
  [20:29:09.734]                   substitute = FALSE, lazy = lazy, seed = seed, 
  [20:29:09.734]                   globals = globals, persistent = persistent, 
  [20:29:09.734]                   workers = workers, user = user, master = myip, 
  [20:29:09.734]                   revtunnel = revtunnel, homogeneous = homogeneous, 
  [20:29:09.734]                   gc = gc, earlySignal = earlySignal, label = label, 
  [20:29:09.734]                   ...)
  [20:29:09.734]                 if (!future$lazy) 
  [20:29:09.734]                   future <- run(future)
  [20:29:09.734]                 invisible(future)
  [20:29:09.734]             }), .cleanup = FALSE, .init = FALSE)
  [20:29:09.734]         }
  [20:29:09.734]         options(...future.oldOptions)
  [20:29:09.734]     })
  [20:29:09.734]     if (is.na(TRUE)) {
  [20:29:09.734]     }
  [20:29:09.734]     else {
  [20:29:09.734]         sink(type = "output", split = FALSE)
  [20:29:09.734]         if (TRUE) {
  [20:29:09.734]             ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
  [20:29:09.734]         }
  [20:29:09.734]         else {
  [20:29:09.734]             ...future.result["stdout"] <- list(NULL)
  [20:29:09.734]         }
  [20:29:09.734]         close(...future.stdout)
  [20:29:09.734]         ...future.stdout <- NULL
  [20:29:09.734]     }
  [20:29:09.734]     ...future.result$conditions <- ...future.conditions
  [20:29:09.734]     ...future.result
  [20:29:09.734] }
  [20:29:09.739] ClusterFuture started
  [20:29:09.739] result() for ClusterFuture ...
  [20:29:09.740] - Validating connection of ClusterFuture
  [20:29:09.997] - class(result): FutureResult
  [20:29:09.997] result() for ClusterFuture ...
  [20:29:09.997] - result already collected: FutureResult
  [20:29:09.998] result() for ClusterFuture ... done
  [20:29:09.998] result() for ClusterFuture ... done
  [20:29:09.998] result() for ClusterFuture ...
  [20:29:09.999] - result already collected: FutureResult
  [20:29:09.999] result() for ClusterFuture ... done
  [20:29:09.999] plan(): plan_init() of 'tweaked', 'remote', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  [20:29:10.000] 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: 11986
  [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-gcc/Work/build/bin/Rscript' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313235a81f69.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313235a81f69.pid')"'
  - Possible to infer worker's PID: TRUE
  [local output] Starting worker #1 on 'localhost': '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313235a81f69.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 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 11986 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11986 cannot be opened
  Killing worker process (PID 23883) if still alive
  [20:29:12.261] Attempting to find a working pid_exists_*() function ...
  Call: tools::pskill(12594, signal = 0L)
  [1] TRUE
  Call: tools::pskill(12594, signal = 0L)
  [1] TRUE
  [20:29:12.262] - success
  [20:29:12.262] Attempting to find a working pid_exists_*() function ... done
  Worker (PID 23883) 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 'gimli2'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 11986 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 11986 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/nbrOfWorkers.R:gimli2:hornik:12594' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/RtmpmvxEug/future.parent=12594.313235a81f69.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11986 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 23883) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'outfile=NULL' to see output from worker.
  Calls: makeClusterPSOCK ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted