Running ‘000.sessionDetails.R’ [9s/12s]
  Running ‘ClusterRegistry.R’ [4s/66s]
  Running ‘Future-class.R’ [2s/24s]
  Running ‘FutureError.R’
  Running ‘FutureGlobals.R’
  Running ‘FutureRegistry.R’
  Running ‘as.cluster.R’ [2s/17s]
  Running ‘availableCores.R’
  Running ‘availableWorkers.R’
  Running ‘backtrace.R’
  Running ‘cluster-missing-future-pkg.R’
  Running ‘cluster.R’ [3s/28s]
  Running ‘constant.R’
  Running ‘demo.R’ [7s/17s]
  Running ‘dotdotdot.R’ [1s/12s]
  Running ‘early-signaling.R’ [2s/25s]
  Running ‘future,labels.R’
  Running ‘future.R’
  Running ‘futureAssign.R’ [2s/11s]
  Running ‘futureAssign_OP.R’ [2s/12s]
  Running ‘futureAssign_OP_with_environment.R’
  Running ‘futureAssign_OP_with_listenv.R’
  Running ‘futureCall.R’ [3s/17s]
  Running ‘futureOf.R’
  Running ‘futureOf_with_environment.R’
  Running ‘futureOf_with_listenv.R’
  Running ‘futures.R’ [12s/82s]
  Running ‘globals,NSE.R’
  Running ‘globals,formulas.R’ [2s/12s]
  Running ‘globals,manual.R’
  Running ‘globals,resolve.R’ [1s/11s]
  Running ‘globals,subassignment.R’ [2s/12s]
  Running ‘globals,toolarge.R’ [1s/10s]
  Running ‘globals,tricky.R’ [5s/15s]
  Running ‘globals,tricky_recursive.R’
  Running ‘globalsOf,tweaks.R’
  Running ‘immediateCondition.R’
  Running ‘invalid-owner.R’ [1s/10s]
  Running ‘makeClusterPSOCK.R’
  Running ‘mandelbrot.R’
  Running ‘mpi.R’
  Running ‘multicore.R’
  Running ‘multiprocess.R’
  Running ‘multisession.R’ [3s/31s]
  Running ‘nbrOfWorkers.R’ [4s/40s]
  Running ‘nested_futures,mc.cores.R’ [4s/69s]
  Running ‘nested_futures.R’
  Running ‘non-exportable,connections.R’ [1s/10s]
  Running ‘objectSize.R’
  Running ‘plan.R’
  Running ‘relaying.R’
  Running ‘remote.R’
  Running ‘requestCore.R’
  Running ‘requestNode.R’ [1s/20s]
  Running ‘resolve.R’
  Running ‘resolved-non-blocking-test.R’ [2s/49s]
  Running ‘rng.R’ [4s/13s]
  Running ‘sequential.R’
  Running ‘sessionDetails.R’
  Running ‘startup.R’ [2s/20s]
  Running ‘stdout.R’ [2s/11s]
  Running ‘transparent.R’
  Running ‘tweak.R’
  Running ‘utils.R’
  Running ‘uuid.R’
  Running ‘whichIndex.R’
Running the tests in ‘tests/cluster.R’ failed.
Complete output:
  > source("incl/start.R")
  [07:10:10.467] plan(): Setting new future strategy stack:
  [07:10:10.468] List of future strategies:
  [07:10:10.468] 1. sequential:
  [07:10:10.468]    - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  [07:10:10.468]    - tweaked: FALSE
  [07:10:10.468]    - call: future::plan("sequential")
  [07:10:10.470] 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.0', '/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) types <- setdiff(types, "FORK")
  > 
  > pid <- Sys.getpid()
  > message("Main PID (original): ", pid)
  Main PID (original): 2317
  > cl <- NULL
  > for (type in types) {
  +   message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
  + 
  +   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)
  +   
  +     ## 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")
  +   
  +     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' ...
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): 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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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.0" "/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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): 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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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.0" "/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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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
  Testing with 2 cores on type = 'PSOCK' ... DONE
  *** cluster() - exceptions ...
  <simpleError in UseMethod("as.cluster"): no applicable method for 'as.cluster' applied to an object of class "logical">
  *** cluster() - exceptions ... DONE
  *** cluster() - assert registry behavior ...
  *** cluster() - assert registry behavior ... DONE
  Main PID (original): 2317
  Main PID: 2317
  socket cluster with 1 nodes on host 'localhost'
  List of 1
   $ :List of 3
    ..$ con : 'sockconn' int 8
    .. ..- attr(*, "conn_id")=<externalptr> 
    ..$ host: chr "localhost"
    ..$ rank: int 1
    ..- attr(*, "class")= chr "SOCKnode"
   - attr(*, "class")= chr [1:2] "SOCKcluster" "cluster"
  Test set #1 with cluster type 'PSOCK' ... DONE
  Test set #1 with cluster type 'FORK' ...
  Testing with 1 cores on type = 'FORK' ...
  socket cluster with 1 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): Whoops!>
  <simpleError in eval(quote({    stop("Whoops!")    1}), new.env()): 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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <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>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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.0" "/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: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  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
  Testing with 1 cores on type = 'FORK' ... DONE
  Testing with 2 cores on type = 'FORK' ...
  socket cluster with 2 nodes on host 'localhost'
  ClusterFuture:
  Label: '<none>'
  Expression:
  {
      42L
  }
  Lazy evaluation: FALSE
  Asynchronous evaluation: TRUE
  Local evaluation: TRUE
  Environment: <environment: R_GlobalEnv>
  Capture standard output: TRUE
  Capture condition classes: 'condition'
  Globals: <none>
  Packages: <none>
  L'Ecuyer-CMRG RNG seed: <none>
  Resolved: TRUE
  Value: <not collected>
  Conditions captured: <none>
  Early signaling: FALSE
  Owner process: 43793021-61fa-0f3c-d5c7-91154babf7f0
  Class: 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
  [1] TRUE
  [1] 42
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 39528 cannot be opened
  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 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 39528 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 39528 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=future/tests/cluster.R:gannet.stats.ox.ac.uk:ripley:2317' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpsJ8Kur/working_dir/RtmpbrEFDt/future.parent=2317.90db6adad4.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=39528 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 5701) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
  Calls: plan ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted