Running ‘000.sessionDetails.R’
  Running ‘ClusterRegistry.R’ [2s/175s]
  Running ‘Future-class.R’ [2s/61s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘backtrace.R’ [2s/68s]
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [2s/101s]
  Running ‘constant.R’
  Running ‘demo.R’ [12s/85s]
  Running ‘dotdotdot.R’ [3s/79s]
  Running ‘early-signaling.R’ [2s/128s]
  Running ‘future,labels.R’ [3s/62s]
  Running ‘future.R’
  Running ‘futureAssign.R’ [3s/53s]
  Running ‘futureAssign_OP.R’ [4s/74s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [5s/106s]
  Running ‘futureOf.R’
  Running ‘futureOf_with_environment.R’
  Running ‘futureOf_with_listenv.R’
  Running ‘futures.R’ [13s/200s]
  Running ‘globals,NSE.R’ [3s/121s]
  Running ‘globals,formulas.R’ [5s/62s]
  Running ‘globals,manual.R’ [8s/56s]
  Running ‘globals,resolve.R’ [2s/36s]
  Running ‘globals,subassignment.R’ [5s/32s]
  Running ‘globals,toolarge.R’ [2s/26s]
  Running ‘globals,tricky.R’ [10s/38s]
  Running ‘globals,tricky_recursive.R’ [2s/24s]
  Running ‘globalsOf,tweaks.R’
  Running ‘immediateCondition.R’
  Running ‘invalid-owner.R’ [2s/26s]
  Running ‘mandelbrot.R’
  Running ‘mpi.R’
  Running ‘multicore,multithreading.R’
  Running ‘multicore.R’
  Running ‘multiprocess.R’
  Running ‘multisession.R’ [3s/71s]
  Running ‘nbrOfWorkers.R’ [4s/109s]
  Running ‘nested_futures,mc.cores.R’ [5s/153s]
  Running ‘nested_futures.R’ [5s/87s]
  Running ‘non-exportable,connections.R’ [1s/22s]
  Running ‘objectSize.R’
  Running ‘plan.R’ [8s/19s]
  Running ‘relaying,split.R’
  Running ‘relaying.R’ [3s/26s]
  Running ‘remote.R’ [2s/22s]
  Running ‘requestCore.R’
  Running ‘requestNode.R’ [2s/37s]
  Running ‘reserved-keyword-functions.R’
  Running ‘resolve.R’ [11s/52s]
  Running ‘resolved-non-blocking-test.R’ [2s/37s]
  Running ‘rng.R’ [15s/36s]
  Running ‘sequential.R’
  Running ‘sessionDetails.R’
  Running ‘startup.R’ [2s/63s]
  Running ‘stdout.R’ [3s/24s]
  Running ‘transparent.R’
  Running ‘tweak.R’ [2s/13s]
  Running ‘utils.R’ [11s/11s]
  Running ‘uuid.R’
  Running ‘whichIndex.R’
Running the tests in ‘tests/cluster.R’ failed.
Complete output:
  > source("incl/start.R")
  [02:35:33.207] plan(): Setting new future strategy stack:
  [02:35:33.209] List of future strategies:
  [02:35:33.209] 1. sequential:
  [02:35:33.209]    - args: function (..., envir = parent.frame())
  [02:35:33.209]    - tweaked: FALSE
  [02:35:33.209]    - call: future::plan("sequential")
  [02:35:33.242] plan(): nbrOfWorkers() = 1
  > library("listenv")
  > options(future.debug = FALSE)
  > message("*** cluster() ...")
  *** cluster() ...
  > 
  > message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
  Library paths: '/data/gannet/ripley/R/packages/tests-devel/future.Rcheck', '/data/gannet/ripley/R/test-4.2', '/data/gannet/ripley/R/R-devel/library'
  > message("Package path: ", sQuote(system.file(package = "future")))
  Package path: '/data/gannet/ripley/R/packages/tests-devel/future.Rcheck/future'
  > 
  > types <- "PSOCK"
  > 
  > ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  > if (isWin32) types <- NULL
  > 
  > if (supportsMulticore() && !on_solaris) types <- c(types, "FORK")
  > 
  > ## WORKAROUND: covr::package_coverage() -> merge_coverage() -> ... produces
  > ## "Error in readRDS(x) : error reading from connection" for type = "FORK".
  > ## Is this related to mcparallel() comments in help("package_coverage")?
  > ## /HB 2017-05-20
  > if (covr_testing || on_githubactions) types <- setdiff(types, "FORK")
  > 
  > ## WORKAROUND: FORK:ed processing gives really odd results on macOS when
  > ## running on GitHub Actions. /HB 2020-06-07
  > if (on_githubactions && on_macos) types <- setdiff(types, "FORK")
  > 
  > pid <- Sys.getpid()
  > message("Main PID (original): ", pid)
  Main PID (original): 1034083
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   message("Main PID (original): ", pid)
  + 
  +   for (cores in 1:availCores) {
  +     message(sprintf("Testing with %d cores on type = %s ...",
  +                     cores, sQuote(type)))
  +     options(mc.cores = cores)
  +   
  +     ## Set up a cluster with <cores> nodes (explicitly)
  +     cl <- parallel::makeCluster(cores, type = type, timeout = 60)
  +     print(cl)
  +     
  +     plan(cluster, workers = cl)
  + 
  +     ## Assert that the worker's global environment is "empty"
  +     f <- future(ls(envir=globalenv(), all.names=TRUE))
  +     v <- value(f)
  +     v <- grep("^[.][.][.]future[.]", v, invert = TRUE, value = TRUE)
  +     if (length(v) > 0) {
  +       stop(sprintf("Stray variables in the global environment of %s: %s",
  +            class(f)[1], paste(sQuote(v), collapse = ", ")))
  +     }
  + 
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  + 
  + 
  +     ## Set up a cluster with <cores> nodes (implicitly)
  +     plan(cluster, workers = cores)
  +   
  +     ## No global variables
  +     f <- try(cluster({
  +       42L
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +   
  +     print(resolved(f))
  +     y <- value(f)
  +     print(y)
  +     stopifnot(y == 42L)
  +   
  +   
  +     ## A global variable
  +     a <- 0
  +     f <- try(future({
  +       b <- 3
  +       c <- 2
  +       a * b * c
  +     }))
  +     print(f)
  +   
  +   
  +     ## A cluster future is evaluated in a separate
  +     ## R session process.  Changing the value of a global
  +     ## variable should not affect the result of the
  +     ## future.
  +     a <- 7  ## Make sure globals are frozen
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == 0)
  +   
  +   
  +     message("*** cluster() with globals and blocking")
  +     x <- listenv()
  +     for (ii in 1:3) {
  +       message(sprintf(" - Creating cluster future #%d ...", ii))
  +       x[[ii]] <- future({ ii })
  +     }
  +     message(sprintf(" - Resolving %d cluster futures", length(x)))
  +     v <- sapply(x, FUN = value)
  +     stopifnot(all(v == 1:3))
  +   
  +   
  +     message("*** cluster() and errors")
  +     f <- future({
  +       stop("Whoops!")
  +       1
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "simpleError"))
  +   
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Error is repeated
  +     res <- tryCatch(value(f), error = identity)
  +     print(res)
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Custom error class
  +     f <- future({
  +       stop(structure(list(message = "boom"),
  +                      class = c("MyError", "error", "condition")))
  +     })
  +     print(f)
  +     v <- value(f, signal = FALSE)
  +     print(v)
  +     stopifnot(inherits(v, "error"), inherits(v, "MyError"))
  +   
  +     ## Make sure error is signaled
  +     res <- tryCatch(value(f), error = identity)
  +     stopifnot(inherits(res, "error"), inherits(res, "MyError"))    
  +   
  +     message("*** cluster() - too large globals ...")
  +     ooptsT <- options(future.globals.maxSize = object.size(1:1014))
  +   
  +     limit <- getOption("future.globals.maxSize")
  +     cat(sprintf("Max total size of globals: %g bytes\n", limit))
  +   
  +     ## A large object
  +     a <- 1:1014
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     f <- future({ sum(a) })
  +     print(f)
  +     rm(list = "a")
  +     v <- value(f)
  +     print(v)
  +     stopifnot(v == yTruth)
  +   
  +   
  +     ## A too large object
  +     a <- 1:1015
  +     yTruth <- sum(a)
  +     size <- object.size(a)
  +     cat(sprintf("a: %g bytes\n", size))
  +     res <- tryCatch(f <- future({ sum(a) }), error = identity)
  +     rm(list = "a")
  +     stopifnot(inherits(res, "error"))
  +   
  +     ## Undo options changed in this test
  +     options(ooptsT)
  +   
  +     message("*** cluster() - too large globals ... DONE")
  +   
  +     message("*** cluster() - installed libraries ...")
  +     f <- try(cluster({
  +       list(
  +         libPaths = .libPaths()
  +       )
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(paste(capture.output(str(v)), collapse = "\n"))
  +     message("*** cluster() - installed packages ... DONE")
  +   
  +   
  +     message("*** cluster() - assert covr workaround ...")
  +     f <- try(cluster({
  +       future:::hpaste(1:100)
  +     }, workers = cl), silent = FALSE)
  +     print(f)
  +     stopifnot(inherits(f, "ClusterFuture"))
  +     v <- value(f)
  +     message(v)
  +     stopifnot(v == hpaste(1:100))
  +     message("*** cluster() - assert covr workaround ... DONE")
  + 
  +     ## Assert that the worker's global environment is "empty"
  +     f <- future(ls(envir=globalenv(), all.names=TRUE))
  +     v <- value(f)
  +     v <- grep("^[.][.][.]future[.]", v, invert = TRUE, value = TRUE)
  +     if (length(v) > 0) {
  +       stop(sprintf("Stray variables in the global environment of %s: %s",
  +            class(f)[1], paste(sQuote(v), collapse = ", ")))
  +     }
  + 
  +     ## Sanity checks
  +     pid2 <- Sys.getpid()
  +     message("Main PID (original): ", pid)
  +     message("Main PID: ", pid2)
  +     stopifnot(pid2 == pid)
  + 
  +     message(sprintf("Testing with %d cores on type = %s ... DONE",
  +                     cores, sQuote(type)))
  +   } ## for (cores ...)
  + 
  +   message("*** cluster() - exceptions ...")
  +   
  +   res <- tryCatch(cluster(42L, workers = NA), error = identity)
  +   print(res)
  +   stopifnot(inherits(res, "error"))
  +   
  +   message("*** cluster() - exceptions ... DONE")
  + 
  +   message("*** cluster() - assert registry behavior ...")
  +   
  +   ## Explicitly created clusters are *not* added to the registry
  +   cl <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   ## ... and therefore changing plans shouldn't change anything
  +   plan(sequential)
  +   clR <- ClusterRegistry("get")
  +   stopifnot(is.null(clR))
  +   
  +   message("*** cluster() - assert registry behavior ... DONE")
  + 
  +   ## Sanity checks
  +   pid2 <- Sys.getpid()
  +   message("Main PID (original): ", pid)
  +   message("Main PID: ", pid2)
  +   stopifnot(pid2 == pid)
  + 
  +   ## Cleanup
  +   print(cl)
  +   str(cl)
  +   parallel::stopCluster(cl)
  +   plan(sequential)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  +   f1 <- future(1)
  + 
  +   cl1 <- parallel::makeCluster(1L, type = type, timeout = 60)
  +   plan(cluster, workers = cl1)
  + 
  +   message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
  + } ## for (type ...)
  Test set #1 with cluster type 'PSOCK' ...
  Main PID (original): 1034083
  Testing with 1 cores on type = 'PSOCK' ...
  socket cluster with 1 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      b <- 3
      c <- 2
      a * b * c
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] 0
  *** cluster() with globals and blocking
   - Creating cluster future #1 ...
   - Creating cluster future #2 ...
   - Creating cluster future #3 ...
   - Resolving 3 cluster futures
  *** cluster() and errors
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      stop("Whoops!")
      1
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  <simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.sendCondition()    sendCondition(cond)    muffleCondition <- function (cond)     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        muffled <- FALSE        if (inherits(cond, "message")) {            invokeRestart("muffleMessage")            muffled <- TRUE        }        else if (inherits(cond, "warning")) {            invokeRestart("muffleWarning")            muffled <- TRUE        }        else if (inherits(cond, "condition")) {            computeRestarts <- base::computeRestarts            grepl <- base::grepl            is.null <- base::is.null            restarts <- computeRestarts(cond)            for (restart in restarts) {                name <- restart$name                if (is.null(name))                   next                if (!grepl("^muffle", name))                   next                invokeRestart(restart)                muffled <- TRUE                break            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
  <simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.sendCondition()    sendCondition(cond)    muffleCondition <- function (cond)     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        muffled <- FALSE        if (inherits(cond, "message")) {            invokeRestart("muffleMessage")            muffled <- TRUE        }        else if (inherits(cond, "warning")) {            invokeRestart("muffleWarning")            muffled <- TRUE        }        else if (inherits(cond, "condition")) {            computeRestarts <- base::computeRestarts            grepl <- base::grepl            is.null <- base::is.null            restarts <- computeRestarts(cond)            for (restart in restarts) {                name <- restart$name                if (is.null(name))                   next                if (!grepl("^muffle", name))                   next                invokeRestart(restart)                muffled <- TRUE                break            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
  <simpleError in withCallingHandlers({    {        stop("Whoops!")        1    }}, immediateCondition = function(cond) {    sendCondition <- ...future.sendCondition()    sendCondition(cond)    muffleCondition <- function (cond)     {        inherits <- base::inherits        invokeRestart <- base::invokeRestart        muffled <- FALSE        if (inherits(cond, "message")) {            invokeRestart("muffleMessage")            muffled <- TRUE        }        else if (inherits(cond, "warning")) {            invokeRestart("muffleWarning")            muffled <- TRUE        }        else if (inherits(cond, "condition")) {            computeRestarts <- base::computeRestarts            grepl <- base::grepl            is.null <- base::is.null            restarts <- computeRestarts(cond)            for (restart in restarts) {                name <- restart$name                if (is.null(name))                   next                if (!grepl("^muffle", name))                   next                invokeRestart(restart)                muffled <- TRUE                break            }        }        invisible(muffled)    }    muffleCondition(cond)}): Whoops!>
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      stop(structure(list(message = "boom"), class = c("MyError", 
          "error", "condition")))
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  <MyError: boom>
  *** cluster() - too large globals ...
  Max total size of globals: 4104 bytes
  a: 4104 bytes
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      sum(a)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: 1 objects totaling 4.01 KiB (integer 'a' of 4.01 KiB)
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] 514605
  a: 4112 bytes
  *** cluster() - too large globals ... DONE
  *** cluster() - installed libraries ...
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      list(libPaths = .libPaths())
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  List of 1
   $ libPaths: chr [1:3] "/data/gannet/ripley/R/packages/tests-devel/future.Rcheck" "/data/gannet/ripley/R/test-4.2" "/data/gannet/ripley/R/R-devel/library"
  *** cluster() - installed packages ... DONE
  *** cluster() - assert covr workaround ...
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      future:::hpaste(1:100)
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100
  *** cluster() - assert covr workaround ... DONE
  Main PID (original): 1034083
  Main PID: 1034083
  Testing with 1 cores on type = 'PSOCK' ... DONE
  Testing with 2 cores on type = 'PSOCK' ...
  socket cluster with 2 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: R_GlobalEnv
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 037f3d85-ec71-ceb8-9482-34b510f87135
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  Error in unserialize(node$con) : error reading from connection
  [1] "Error in unserialize(node$con) : error reading from connection\n"
  attr(,"class")
  [1] "try-error"
  attr(,"condition")
  <simpleError in unserialize(node$con): error reading from connection>
  Error: inherits(f, "ClusterFuture") is not TRUE
  Execution halted