Running ‘000.sessionDetails.R’ [0s/1s]
  Running ‘ClusterRegistry.R’ [1s/4s]
  Running ‘Future-class.R’ [1s/2s]
  Running ‘FutureError.R’ [1s/1s]
  Running ‘FutureGlobals.R’ [1s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/2s]
  Running ‘availableCores.R’ [1s/1s]
  Running ‘availableWorkers.R’ [1s/1s]
  Running ‘backtrace.R’ [1s/1s]
  Running ‘cluster-missing-future-pkg.R’ [1s/2s]
  Running ‘cluster.R’ [2s/15s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [2s/4s]
  Running ‘dotdotdot.R’ [1s/3s]
  Running ‘early-signaling.R’ [1s/7s]
  Running ‘future,labels.R’ [1s/2s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [1s/3s]
  Running ‘futureAssign_OP.R’ [2s/5s]
  Running ‘futureAssign_OP_with_environment.R’ [1s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [3s/6s]
  Running ‘futureOf.R’ [1s/1s]
  Running ‘futureOf_with_environment.R’ [1s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [9s/34s]
  Running ‘globals,NSE.R’ [1s/4s]
  Running ‘globals,formulas.R’ [3s/6s]
  Running ‘globals,manual.R’ [3s/6s]
  Running ‘globals,resolve.R’ [1s/3s]
  Running ‘globals,subassignment.R’ [2s/4s]
  Running ‘globals,toolarge.R’ [1s/2s]
  Running ‘globals,tricky.R’ [5s/11s]
  Running ‘globals,tricky_recursive.R’ [1s/3s]
  Running ‘globalsOf,tweaks.R’ [1s/1s]
  Running ‘invalid-owner.R’ [1s/3s]
  Running ‘makeClusterPSOCK.R’ [1s/1s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘multicore.R’ [1s/1s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [3s/14s]
  Running ‘nbrOfWorkers.R’ [1s/6s]
  Running ‘nested_futures,mc.cores.R’ [2s/19s]
  Running ‘nested_futures.R’ [2s/8s]
  Running ‘non-exportable,connections.R’ [1s/2s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [1s/11s]
  Running ‘remote.R’ [1s/2s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/3s]
  Running ‘resolve.R’ [4s/45s]
  Running ‘rng.R’ [4s/12s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [1s/3s]
  Running ‘stdout.R’ [1s/2s]
  Running ‘transparent.R’ [1s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [1s/2s]
  Running ‘uuid.R’ [1s/1s]
Running the tests in ‘tests/uuid.R’ failed.
Complete output:
  > source("incl/start.R")
  plan(): nbrOfWorkers() = 1
  > session_uuid <- future:::session_uuid
  > add_cluster_uuid <- future:::add_cluster_uuid
  > 
  > message("*** session_uuid() ...")
  *** session_uuid() ...
  > 
  > id0 <- session_uuid()
  > print(id0)
  [1] "f298c0d4-5cb1-cbac-a0fb-0212367bdd25"
  attr(,"source")
  attr(,"source")$host
  [1] "gimli"
  
  attr(,"source")$info
                                 sysname                                release 
                                 "Linux"                       "4.16.0-2-amd64" 
                                 version                               nodename 
  "#1 SMP Debian 4.16.12-1 (2018-05-27)"                                "gimli" 
                                 machine                                  login 
                                "x86_64"                               "hornik" 
                                    user                         effective_user 
                                "hornik"                               "hornik" 
  
  attr(,"source")$pid
  [1] 18189
  
  attr(,"source")$time
  [1] "2018-08-18 08:30:52 CEST"
  
  attr(,"source")$random
  [1] 1376225610
  
  > 
  > ## Reset session UUID (hack)
  > environment(session_uuid)$uuids <- list()
  > 
  > id <- session_uuid()
  > print(id)
  [1] "eb52cad0-8478-7352-dd33-ffdef15bdd29"
  attr(,"source")
  attr(,"source")$host
  [1] "gimli"
  
  attr(,"source")$info
                                 sysname                                release 
                                 "Linux"                       "4.16.0-2-amd64" 
                                 version                               nodename 
  "#1 SMP Debian 4.16.12-1 (2018-05-27)"                                "gimli" 
                                 machine                                  login 
                                "x86_64"                               "hornik" 
                                    user                         effective_user 
                                "hornik"                               "hornik" 
  
  attr(,"source")$pid
  [1] 18189
  
  attr(,"source")$time
  [1] "2018-08-18 08:30:52 CEST"
  
  attr(,"source")$random
  [1] 270631203
  
  > stopifnot(id != id0)
  > 
  > ## Assert that forked child processes get a unique session id
  > ## Issue: https://github.com/HenrikBengtsson/future/issues/187
  > if (supportsMulticore()) {
  +   plan(multicore, workers = 2L)
  +   fs <- lapply(1:2, FUN = function(i) {
  +     future({
  +       Sys.sleep(0.2)
  +       session_uuid()
  +     })
  +   })
  +   ids <- unlist(values(fs))
  +   print(ids)
  +   stopifnot(all(ids != id), length(unique(ids)) == 2L)
  + }
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  Searching for globals ...
  - globals found: [28] '{', 'Sys.sleep', 'session_uuid', 'Sys.getpid', '<-', 'as.character', '[[', 'uuids', 'if', '!', 'is.null', 'attr', 'attr<-', 'return', 'Sys.info', 'Sys.getenv', 'c', '[', 'nzchar', '==', 'length', 'list', 'Sys.time', 'sample.int', '$', '.Machine', '<<-', '[[<-'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 2 globals is 15.09 KiB (15448 bytes)
  - globals: [2] 'session_uuid', 'uuids'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = NULL, 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  ...future.mc.cores.old <- getOption("mc.cores")
                  options(mc.cores = 1L)
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              Sys.sleep(0.2)
              session_uuid()
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = 2L, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  getGlobalsAndPackages() ...
  Searching for globals ...
  plan(): nbrOfWorkers() = 1
  - globals found: [28] '{', 'Sys.sleep', 'session_uuid', 'Sys.getpid', '<-', 'as.character', '[[', 'uuids', 'if', '!', 'is.null', 'attr', 'attr<-', 'return', 'Sys.info', 'Sys.getenv', 'c', '[', 'nzchar', '==', 'length', 'list', 'Sys.time', 'sample.int', '$', '.Machine', '<<-', '[[<-'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 2 globals is 15.09 KiB (15448 bytes)
  - globals: [2] 'session_uuid', 'uuids'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = NULL, 
              future.globals.onReference = NULL, future.globals.resolve = NULL, 
              future.resolve.recursive = NULL, width = 80L)
          {
              {
                  {
                    has_future <- requireNamespace("future", quietly = TRUE)
                    version <- if (has_future) 
                      packageVersion("future")
                    else NULL
                    if (!has_future || version < "1.8.0") {
                      info <- c(r_version = gsub("R version ", 
                        "", R.version$version.string), platform = sprintf("%s (%s-bit)", 
                        R.version$platform, 8 * .Machine$sizeof.pointer), 
                        os = paste(Sys.info()[c("sysname", "release", 
                          "version")], collapse = " "), hostname = Sys.info()[["nodename"]])
                      info <- sprintf("%s: %s", names(info), info)
                      info <- paste(info, collapse = "; ")
                      if (!has_future) {
                        msg <- sprintf("Package 'future' is not installed on worker (%s)", 
                          info)
                      }
                      else {
                        msg <- sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
                          info, version)
                      }
                      stop(msg)
                    }
                  }
                  ...future.mc.cores.old <- getOption("mc.cores")
                  options(mc.cores = 1L)
              }
              future::plan("default", .cleanup = FALSE, .init = FALSE)
          }
      }
      if (is.na(TRUE)) {
      }
      else {
          if (TRUE) {
              ...future.stdout <- rawConnection(raw(0L), open = "w")
          }
          else {
              ...future.stdout <- file(switch(.Platform$OS.type, 
                  windows = "NUL", "/dev/null"), open = "w")
          }
          sink(...future.stdout, type = "output", split = FALSE)
          on.exit(if (!is.null(...future.stdout)) {
              sink(type = "output", split = FALSE)
              close(...future.stdout)
          }, add = TRUE)
      }
      ...future.result <- tryCatch({
          ...future.value <- local({
              Sys.sleep(0.2)
              session_uuid()
          })
          future::FutureResult(value = ...future.value, version = "1.8")
      }, error = function(cond) {
          calls <- sys.calls()
          structure(list(value = NULL, value2 = NA, condition = cond, 
              calls = calls, version = "1.8"), class = "FutureResult")
      }, finally = {
          {
              {
                  {
                    options(mc.cores = ...future.mc.cores.old)
                  }
                  future::plan(list(function (expr, envir = parent.frame(), 
                    substitute = TRUE, lazy = FALSE, seed = NULL, 
                    globals = TRUE, workers = 2L, earlySignal = FALSE, 
                    label = NULL, ...) 
                  {
                    if (substitute) 
                      expr <- substitute(expr)
                    if (is.function(workers)) 
                      workers <- workers()
                    workers <- as.integer(workers)
                    stop_if_not(is.finite(workers), workers >= 
                      1L)
                    if (workers == 1L || !supportsMulticore()) {
                      return(sequential(expr, envir = envir, substitute = FALSE, 
                        lazy = lazy, seed = seed, globals = globals, 
                        local = TRUE, label = label))
                    }
                    oopts <- options(mc.cores = workers)
                    on.exit(options(oopts))
                    future <- MulticoreFuture(expr = expr, envir = envir, 
                      substitute = FALSE, lazy = lazy, seed = seed, 
                      globals = globals, workers = workers, earlySignal = earlySignal, 
                      label = label, ...)
                    if (!future$lazy) 
                      future <- run(future)
                    invisible(future)
                  }), .cleanup = FALSE, .init = FALSE)
              }
              options(...future.oldOptions)
          }
      })
      if (is.na(TRUE)) {
      }
      else {
          sink(type = "output", split = FALSE)
          if (TRUE) {
              ...future.result$stdout <- rawToChar(rawConnectionValue(...future.stdout))
          }
          else {
              ...future.result["stdout"] <- list(NULL)
          }
          close(...future.stdout)
          ...future.stdout <- NULL
      }
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  resolve() on list ...
   recursive: 0
   length: 2
  
  plan(): nbrOfWorkers() = 1
   length: 1 (resolved future 1)
   length: 0 (resolved future 2)
  resolve() on list ... DONE
  [1] "6d4a97d7-2e42-8ba3-c7cf-ca00fb9116d5"
  [2] "1aa0e46e-53bc-7bc5-3c09-ef27012d6605"
  > 
  > message("*** session_uuid() ... DONE")
  *** session_uuid() ... DONE
  > 
  > message("*** add_cluster_uuid() ...")
  *** add_cluster_uuid() ...
  > 
  > cl <- parallel::makeCluster(1L, type = "PSOCK")
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11463 cannot be opened
  Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
    cannot open the connection
  Calls: <Anonymous> ... makePSOCKcluster -> newPSOCKnode -> socketConnection
  Execution halted