Running ‘000.sessionDetails.R’ [5s/7s]
  Running ‘ClusterRegistry.R’ [2s/49s]
  Running ‘Future-class.R’ [1s/16s]
  Running ‘FutureError.R’ [0s/1s]
  Running ‘FutureGlobals.R’ [0s/1s]
  Running ‘FutureRegistry.R’ [1s/1s]
  Running ‘as.cluster.R’ [1s/19s]
  Running ‘availableCores.R’ [0s/1s]
  Running ‘availableWorkers.R’ [0s/1s]
  Running ‘backtrace.R’ [1s/3s]
  Running ‘cluster-missing-future-pkg.R’ [1s/3s]
  Running ‘cluster.R’ [5s/114s]
  Running ‘constant.R’ [0s/1s]
  Running ‘demo.R’ [7s/27s]
  Running ‘dotdotdot.R’ [1s/18s]
  Running ‘early-signaling.R’ [2s/37s]
  Running ‘future,labels.R’ [1s/19s]
  Running ‘future.R’ [1s/1s]
  Running ‘futureAssign.R’ [2s/17s]
  Running ‘futureAssign_OP.R’ [2s/19s]
  Running ‘futureAssign_OP_with_environment.R’ [0s/1s]
  Running ‘futureAssign_OP_with_listenv.R’ [1s/1s]
  Running ‘futureCall.R’ [4s/29s]
  Running ‘futureOf.R’ [0s/1s]
  Running ‘futureOf_with_environment.R’ [0s/1s]
  Running ‘futureOf_with_listenv.R’ [1s/1s]
  Running ‘futures.R’ [13s/140s]
  Running ‘globals,NSE.R’ [2s/22s]
  Running ‘globals,formulas.R’ [3s/22s]
  Running ‘globals,manual.R’ [4s/25s]
  Running ‘globals,resolve.R’ [1s/19s]
  Running ‘globals,subassignment.R’ [3s/22s]
  Running ‘globals,toolarge.R’ [1s/20s]
  Running ‘globals,tricky.R’ [6s/27s]
  Running ‘globals,tricky_recursive.R’ [1s/18s]
  Running ‘globalsOf,tweaks.R’ [0s/1s]
  Running ‘invalid-owner.R’ [1s/18s]
  Running ‘makeClusterPSOCK.R’ [1s/9s]
  Running ‘mandelbrot.R’ [1s/1s]
  Running ‘mpi.R’ [0s/1s]
  Running ‘multicore.R’ [1s/1s]
  Running ‘multiprocess.R’ [1s/2s]
  Running ‘multisession.R’ [3s/56s]
  Running ‘nbrOfWorkers.R’ [4s/83s]
  Running ‘nested_futures,mc.cores.R’ [4s/121s]
  Running ‘nested_futures.R’ [4s/71s]
  Running ‘non-exportable,connections.R’ [1s/17s]
  Running ‘objectSize.R’ [1s/1s]
  Running ‘plan.R’ [4s/14s]
  Running ‘remote.R’ [1s/16s]
  Running ‘requestCore.R’ [1s/3s]
  Running ‘requestNode.R’ [1s/29s]
  Running ‘resolve.R’ [5s/45s]
  Running ‘rng.R’ [5s/26s]
  Running ‘sequential.R’ [1s/1s]
  Running ‘sessionDetails.R’ [1s/1s]
  Running ‘startup.R’ [2s/37s]
  Running ‘stdout.R’ [2s/20s]
  Running ‘transparent.R’ [0s/1s]
  Running ‘tweak.R’ [1s/1s]
  Running ‘utils.R’ [5s/9s]
  Running ‘uuid.R’ [1s/1s]
  Running ‘whichIndex.R’ [0s/1s]
Running the tests in ‘tests/globals,NSE.R’ failed.
Complete output:
  > source("incl/start.R")
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: future::plan("sequential")
  
  plan(): nbrOfWorkers() = 1
  > library("listenv")
  > 
  > message("*** Globals w/ non-standard evaluation (NSE) ...")
  *** Globals w/ non-standard evaluation (NSE) ...
  > 
  > data <- data.frame(x = 1:5, y = 1:5)
  > v0 <- subset(data, x < 3)$y
  > 
  > for (strategy in supportedStrategies()) {
  +   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
  +   if (!fullTest && isWin32) next
  +   
  +   message(sprintf("- Strategy: %s ...", strategy))
  +   
  +   plan(strategy)
  + 
  +   ## Assert option is passed on to future
  +   options(future.globals.onMissing = "error")
  +   opt1 %<-% getOption("future.globals.onMissing")
  +   stopifnot(identical(opt1, "error"))
  + 
  +   options(future.globals.onMissing = "ignore")
  +   opt2 %<-% getOption("future.globals.onMissing")
  +   stopifnot(identical(opt2, "ignore"))
  + 
  +   options(future.globals.onMissing = "error")
  +   res <- try({ v1 %<-% subset(data, x < 3)$y }, silent = TRUE)
  +   stopifnot(inherits(res, "try-error"))
  + 
  +   options(future.globals.onMissing = "ignore")
  +   v2 %<-% subset(data, x < 3)$y
  +   stopifnot(identical(v2, v0))
  + 
  +   ## Nested futures (requires option is passed on to future)
  +   plan(list(sequential, strategy))
  +   options(future.globals.onMissing = "ignore")
  +   v3 %<-% {
  +     a %<-% subset(data, x < 3)$y
  +     a
  +   } %lazy% TRUE
  +   stopifnot(identical(v3, v0))
  + 
  +   message(sprintf("- Strategy: %s ... DONE", strategy))
  + }
  - Strategy: sequential ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "error", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "error", 
              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::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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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::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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  getGlobalsAndPackages() ...
  Searching for globals...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] '$', 'subset', 'data', '<', 'x'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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::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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(subset(data, x < 3)$y)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [8] '{', '<-', '$', 'subset', 'data', '<', 'x', '%<-%'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  - packages: [1] 'future'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'future'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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)
                    }
                  }
                  local({
                    for (pkg in "future") {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  a %<-% subset(data, x < 3)$y
                  a
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, 
                  earlySignal = FALSE, label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Future state: 'finished'
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] '$', 'subset', 'data', '<', 'x'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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::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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(subset(data, x < 3)$y)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  - Strategy: sequential ... DONE
  - Strategy: multicore ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "error", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "error", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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 = availableCores(constraints = "multicore"), 
                  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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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 = availableCores(constraints = "multicore"), 
                  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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  Searching for globals...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] '$', 'subset', 'data', '<', 'x'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(subset(data, x < 3)$y)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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 = availableCores(constraints = "multicore"), 
                  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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: NULL
  
  plan(): nbrOfWorkers() = 1
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [8] '{', '<-', '$', 'subset', 'data', '<', 'x', '%<-%'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  - packages: [1] 'future'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'future'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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)
                    }
                  }
                  local({
                    for (pkg in "future") {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  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)
          }
      }
      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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  a %<-% subset(data, x < 3)$y
                  a
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), 
                  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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. multicore:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Future state: 'finished'
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] '$', 'subset', 'data', '<', 'x'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(subset(data, x < 3)$y)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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 = availableCores(constraints = "multicore"), 
                  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$conditions <- ...future.conditions
      ...future.result
  }
  requestCore(): workers = 2
  MulticoreFuture started
  - Strategy: multicore ... DONE
  - Strategy: multisession ...
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(strategy)
  
  plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
  multisession:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: FALSE
  - call: plan(strategy)
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11811
  [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/Rtmp4Wd8lJ/future.parent=12100.2f44491f2f1b.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f44491f2f1b.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/globals,NSE.R:gimli2:hornik:12100' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f44491f2f1b.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11811 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/Rtmp4Wd8lJ/future.parent=12100.2f447903d34e.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f447903d34e.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/globals,NSE.R:gimli2:hornik:12100' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f447903d34e.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11811 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
  getGlobalsAndPackages() ...
  Not searching for globals
  - globals: [0] <none>
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(NA)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, 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$conditions <- ...future.conditions
      ...future.result
  }
  MultisessionFuture started
  result() for ClusterFuture ...
  - Validating connection of MultisessionFuture
  - class(result): FutureResult
  plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
  plan(): nbrOfWorkers() = 2
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "error", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "error", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, 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$conditions <- ...future.conditions
      ...future.result
  }
  MultisessionFuture started
  result() for ClusterFuture ...
  - Validating connection of MultisessionFuture
  - class(result): FutureResult
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [1] 'getOption'
  Searching for globals ... DONE
  Resolving globals: FALSE
  
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(getOption("future.globals.onMissing"))
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, 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$conditions <- ...future.conditions
      ...future.result
  }
  MultisessionFuture started
  result() for ClusterFuture ...
  - Validating connection of MultisessionFuture
  - class(result): FutureResult
  getGlobalsAndPackages() ...
  Searching for globals...
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [5] '$', 'subset', 'data', '<', 'x'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 0): <none>
  Packages needed by the future expression (n = 0): <none>
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local(subset(data, x < 3)$y)
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.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, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, 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$conditions <- ...future.conditions
      ...future.result
  }
  Exporting 1 global objects (160 bytes) to cluster node #1 ...
  Exporting 'data' (160 bytes) to cluster node #1 ...
  Exporting 'data' (160 bytes) to cluster node #1 ... DONE
  Exporting 1 global objects (160 bytes) to cluster node #1 ... DONE
  MultisessionFuture started
  result() for ClusterFuture ...
  - Validating connection of MultisessionFuture
  - class(result): FutureResult
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  getGlobalsAndPackages() ...
  Searching for globals...
  - globals found: [8] '{', '<-', '$', 'subset', 'data', '<', 'x', '%<-%'
  Searching for globals ... DONE
  Resolving globals: FALSE
  The total size of the 1 globals is 160 bytes (160 bytes)
  - globals: [1] 'data'
  - packages: [1] 'future'
  getGlobalsAndPackages() ... DONE
  Packages needed by future strategies (n = 1): 'future'
  Packages needed by the future expression (n = 1): 'future'
  {
      {
          ...future.startTime <- Sys.time()
          ...future.oldOptions <- options(future.startup.loadScript = FALSE, 
              future.globals.onMissing = "ignore", future.globals.maxSize = NULL, 
              future.globals.method = NULL, future.globals.onMissing = "ignore", 
              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)
                    }
                  }
                  local({
                    for (pkg in "future") {
                      loadNamespace(pkg)
                      library(pkg, character.only = TRUE)
                    }
                  })
              }
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, persistent = FALSE, workers = availableCores(), 
                  gc = FALSE, earlySignal = FALSE, label = NULL, 
                  ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }), .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.frame <- sys.nframe()
      ...future.conditions <- list()
      ...future.result <- tryCatch({
          withCallingHandlers({
              ...future.value <- local({
                  a %<-% subset(data, x < 3)$y
                  a
              })
              future::FutureResult(value = ...future.value, started = ...future.startTime, 
                  version = "1.8")
          }, condition = local({
              inherits <- base::inherits
              invokeRestart <- base::invokeRestart
              length <- base::length
              seq.int <- base::seq.int
              sys.calls <- base::sys.calls
              `[[` <- base::`[[`
              `+` <- base::`+`
              `<<-` <- base::`<<-`
              sysCalls <- function(calls = sys.calls(), from = 1L) {
                  calls[seq.int(from = from + 12L, to = length(calls) - 
                    3L)]
              }
              function(cond) {
                  if (inherits(cond, "error")) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
                      cond$call), timestamp = base::Sys.time())
                    signalCondition(cond)
                  }
                  else if (inherits(cond, c("message", "warning"
                  ))) {
                    ...future.conditions[[length(...future.conditions) + 
                      1L]] <<- list(condition = cond)
                    if (inherits(cond, "message")) {
                      invokeRestart("muffleMessage")
                    }
                    else if (inherits(cond, "warning")) {
                      invokeRestart("muffleWarning")
                    }
                  }
              }
          }))
      }, error = function(ex) {
          structure(list(value = NULL, conditions = ...future.conditions, 
              condition = ex, calls = sys.calls(), version = "1.8"), 
              class = "FutureResult")
      }, finally = {
          {
              NULL
              future::plan(list(function (expr, envir = parent.frame(), 
                  substitute = TRUE, lazy = FALSE, seed = NULL, 
                  globals = TRUE, local = TRUE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  local <- as.logical(local)
                  future <- SequentialFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, local = local, earlySignal = earlySignal, 
                    label = label, ...)
                  if (!future$lazy) 
                    future <- run(future)
                  invisible(future)
              }, function (expr, envir = parent.frame(), substitute = TRUE, 
                  lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, 
                  workers = availableCores(), gc = FALSE, earlySignal = FALSE, 
                  label = NULL, ...) 
              {
                  if (substitute) 
                    expr <- substitute(expr)
                  if (is.function(workers)) 
                    workers <- workers()
                  workers <- as.integer(workers)
                  stop_if_not(length(workers) == 1, is.finite(workers), 
                    workers >= 1)
                  if (workers == 1L) {
                    return(sequential(expr, envir = envir, substitute = FALSE, 
                      lazy = TRUE, seed = seed, globals = globals, 
                      local = TRUE, label = label, ...))
                  }
                  workers <- ClusterRegistry("start", workers = workers)
                  future <- MultisessionFuture(expr = expr, envir = envir, 
                    substitute = FALSE, lazy = lazy, seed = seed, 
                    globals = globals, persistent = persistent, 
                    workers = workers, gc = gc, 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$conditions <- ...future.conditions
      ...future.result
  }
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 2
  plan(): Setting new future strategy stack:
  List of future strategies:
  1. sequential:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  2. multisession:
     - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = availableCores(), gc = FALSE, earlySignal = FALSE, label = NULL, ...)
     - tweaked: FALSE
     - call: plan(list(sequential, strategy))
  
  plan(): nbrOfWorkers() = 1
  SequentialFuture started (and completed)
  Call: tools::pskill(12100, signal = 0L)
  [1] TRUE
  Call: tools::pskill(12100, signal = 0L)
  [1] TRUE
  Future state: 'finished'
  [local output] Workers: [n = 2] 'localhost', 'localhost'
  [local output] Base port: 11811
  [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/Rtmp4Wd8lJ/future.parent=12100.2f443f1cd39d.pid"), silent = TRUE)' -e "file.exists('/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f443f1cd39d.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/globals,NSE.R:gimli2:hornik:12100' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f443f1cd39d.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11811 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 11811 cannot be opened'
  Warning in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
    port 11811 cannot be opened
  Killing worker process (PID 20917) if still alive
  Attempting to find a working pid_exists_*() function ...
  - success
  Attempting to find a working pid_exists_*() function ... done
  Worker (PID 20917) 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 11811 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 11811 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/globals,NSE.R:gimli2:hornik:12100' -e 'try(cat(Sys.getpid(),file="/home/hornik/tmp/scratch/Rtmp4Wd8lJ/future.parent=12100.2f443f1cd39d.pid"), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=11811 OUT=/dev/null
  Calls: stopifnot ... eval -> value -> value.Future -> resignalConditions
  Execution halted