Running 'BatchtoolsFuture,gc.R' [6s]
  Running 'BatchtoolsFuture.R' [6s]
  Running 'BatchtoolsFutureError.R' [13s]
  Running 'batchtools_custom.R' [13s]
  Running 'batchtools_hpc.R' [1s]
  Running 'batchtools_interactive.R' [4s]
  Running 'batchtools_local.R' [12s]
  Running 'batchtools_multicore.R' [19s]
  Running 'batchtools_template.R' [2s]
  Running 'demo.R' [11s]
  Running 'dotdotdot.R' [12s]
  Running 'future,labels.R' [13s]
  Running 'future,lazy.R' [6s]
  Running 'globals,formulas.R' [24s]
  Running 'globals,manual.R' [18s]
  Running 'globals,subassignment.R' [18s]
  Running 'globals,tricky.R' [20s]
  Running 'nbrOfWorkers.R' [1s]
  Running 'plan.R' [7s]
  Running 'resources_OP.R' [4s]
  Running 'stdout.R' [14s]
  Running 'utils.R' [1s]
  Running 'zzz,future_lapply.R' [33s]
  Running 'zzz.onUnload.R' [1s]
Running the tests in 'tests/zzz,future_lapply.R' failed.
Complete output:
  > source("incl/start.R")
  Loading required package: future
  > 
  > if (requireNamespace("future.apply", quietly = TRUE)) {
  +   future_lapply <- future.apply::future_lapply
  +   library("listenv")
  + 
  +   ## Setup all strategies including custom once for testing on HPC environments
  +   print(all_strategies())
  + 
  +   message("All HPC strategies:")
  +   strategies <- c("batchtools_lsf", "batchtools_openlava", "batchtools_sge",
  +                   "batchtools_slurm", "batchtools_torque")
  +   mprint(strategies, debug = TRUE)
  +   
  +   message("Supported HPC strategies:")
  +   strategies <- strategies[sapply(strategies, FUN = test_strategy)]
  +   mprint(strategies, debug = TRUE)
  + 
  +   strategies <- c("batchtools_local", strategies)
  +   
  +   if (fullTest) {
  +     strategies <- c("batchtools_interactive", strategies)
  +     
  +     batchtools_custom_local <- function(expr, substitute = TRUE,
  +         cluster.functions = batchtools::makeClusterFunctionsInteractive(external = TRUE), ...) {
  +       if (substitute) expr <- substitute(expr)
  +       batchtools_custom(expr, substitute = FALSE, ...,
  +                         cluster.functions = cluster.functions)
  +     }
  +     class(batchtools_custom_local) <- c("batchtools_custom_local",
  +                                         class(batchtools_custom))
  +     strategies <- c("batchtools_custom_local", strategies)
  +   }
  + 
  +   ## CRAN processing times: Don't run these tests on Windows 32-bit
  +   if (!fullTest && isWin32) strategies <- character(0L)
  +   
  +   message("Strategies to test with:")
  +   mprint(strategies, debug = TRUE)
  +   
  +   
  +   message("*** future_lapply() ...")
  +   
  +   message("- future_lapply(x, FUN = vector, ...) ...")
  +   
  +   x <- list(a = "integer", c = "character", c = "list")
  +   str(list(x = x))
  + 
  +   y0 <- lapply(x, FUN = vector, length = 2L)
  +   str(list(y0 = y0))
  + 
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...\n", strategy)
  +     plan(strategy)
  +     mprint(plan, debug = TRUE)
  +     if (nbrOfWorkers() > 2) plan(strategy, workers = 2L)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = vector, length = 2L,
  +                          future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN = base::vector, ...) ...")
  +   
  +   x <- list(a = "integer", c = "character", c = "list")
  +   str(list(x = x))
  +   
  +   y0 <- lapply(x, FUN = base::vector, length = 2L)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...\n", strategy)
  +     plan(strategy)
  +     mprint(plan, debug = TRUE)
  +     if (nbrOfWorkers() > 2) plan(strategy, workers = 2L)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = base::vector, length = 2L,
  +                          future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   message("- future_lapply(x, FUN = future:::hpaste, ...) ...")
  +   
  +   x <- list(a = c("hello", b = 1:100))
  +   str(list(x = x))
  +   
  +   y0 <- lapply(x, FUN = future:::hpaste, collapse = "; ", maxHead = 3L)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...\n", strategy)
  +     plan(strategy)
  +     mprint(plan, debug = TRUE)
  +     if (nbrOfWorkers() > 2) plan(strategy, workers = 2L)
  +     stopifnot(nbrOfWorkers() < Inf)
  +   
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = future:::hpaste, collapse = "; ",
  +                          maxHead = 3L, future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN = listenv::listenv, ...) ...")
  +   
  +   x <- list()
  +   
  +   y <- listenv()
  +   y$A <- 3L
  +   x$a <- y
  +   
  +   y <- listenv()
  +   y$A <- 3L
  +   y$B <- c("hello", b = 1:100)
  +   x$b <- y
  +   
  +   print(x)
  +   
  +   y0 <- lapply(x, FUN = listenv::map)
  +   str(list(y0 = y0))
  +   
  +   for (strategy in strategies) {
  +     mprintf("- plan('%s') ...\n", strategy)
  +     plan(strategy)
  +     if (nbrOfWorkers() > 2) plan(strategy, workers = 2L)
  +     stopifnot(nbrOfWorkers() < Inf)
  +     
  +     for (scheduling in list(FALSE, TRUE)) {
  +       y <- future_lapply(x, FUN = listenv::map, future.scheduling = scheduling)
  +       str(list(y = y))
  +       stopifnot(identical(y, y0))
  +     }
  +   }
  +   
  +   
  +   message("- future_lapply(x, FUN, ...) for large length(x) ...")
  +   a <- 3.14
  +   x <- 1:1e5
  +   
  +   y <- future_lapply(x, FUN = function(z) sqrt(z + a))
  +   y <- unlist(y, use.names = FALSE)
  +   
  +   stopifnot(all.equal(y, sqrt(x + a)))
  +   
  +   
  +   message("- future_lapply() with global in non-attached package ...")
  +   library("tools")
  +   my_ext <- function(x) file_ext(x)
  +   y_truth <- lapply("abc.txt", FUN = my_ext)
  +   
  +   for (strategy in strategies) {
  +     plan(strategy)
  +     if (nbrOfWorkers() > 2) plan(strategy, workers = 2L)
  +     stopifnot(nbrOfWorkers() < Inf)
  +     y <- future_lapply("abc.txt", FUN = my_ext)
  +     stopifnot(identical(y, y_truth))
  +   }
  +   
  +   message("*** future_lapply() ... DONE")
  + }
  [1] "sequential"   "multisession" "multiprocess" "cluster"     
  All HPC strategies:
  [11:21:00.720] [1] "batchtools_lsf"      "batchtools_openlava" "batchtools_sge"     
  [11:21:00.720] [4] "batchtools_slurm"    "batchtools_torque"  
  Supported HPC strategies:
  [11:21:00.720] character(0)
  Strategies to test with:
  [11:21:00.735] [1] "batchtools_local"
  *** future_lapply() ...
  - future_lapply(x, FUN = vector, ...) ...
  List of 1
   $ x:List of 3
    ..$ a: chr "integer"
    ..$ c: chr "character"
    ..$ c: chr "list"
  List of 1
   $ y0:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  - plan('batchtools_local') ...
  [11:21:00.876] function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, 
  [11:21:00.876]     .call = TRUE, .cleanup = TRUE, .init = TRUE) 
  [11:21:00.876] {
  [11:21:00.876]     if (substitute) 
  [11:21:00.876]         strategy <- substitute(strategy)
  [11:21:00.876]     if (is.logical(.skip)) 
  [11:21:00.876]         stop_if_not(length(.skip) == 1L, !is.na(.skip))
  [11:21:00.876]     if (is.logical(.call)) 
  [11:21:00.876]         stop_if_not(length(.call) == 1L, !is.na(.call))
  [11:21:00.876]     if (is.null(strategy) || identical(strategy, "next")) {
  [11:21:00.876]         strategy <- stack[[1L]]
  [11:21:00.876]         if (!inherits(strategy, "FutureStrategy")) {
  [11:21:00.876]             class(strategy) <- c("FutureStrategy", class(strategy))
  [11:21:00.876]         }
  [11:21:00.876]         stop_if_not(is.function(strategy))
  [11:21:00.876]         return(strategy)
  [11:21:00.876]     }
  [11:21:00.876]     else if (identical(strategy, "default")) {
  [11:21:00.876]         strategy <- getOption("future.plan", sequential)
  [11:21:00.876]     }
  [11:21:00.876]     else if (identical(strategy, "list")) {
  [11:21:00.876]         return(stack)
  [11:21:00.876]     }
  [11:21:00.876]     else if (identical(strategy, "reset")) {
  [11:21:00.876]         stack <<- defaultStack
  [11:21:00.876]         if (.cleanup) 
  [11:21:00.876]             plan_cleanup()
  [11:21:00.876]         return(stack)
  [11:21:00.876]     }
  [11:21:00.876]     else if (identical(strategy, "pop")) {
  [11:21:00.876]         oldStack <- stack
  [11:21:00.876]         stack <<- stack[-1L]
  [11:21:00.876]         if (length(stack) == 0L) 
  [11:21:00.876]             stack <<- defaultStack
  [11:21:00.876]         return(oldStack)
  [11:21:00.876]     }
  [11:21:00.876]     oldStack <- stack
  [11:21:00.876]     newStack <- NULL
  [11:21:00.876]     targs <- list(...)
  [11:21:00.876]     if (is.function(strategy)) {
  [11:21:00.876]         strategy <- list(strategy)
  [11:21:00.876]     }
  [11:21:00.876]     if (is.list(strategy)) {
  [11:21:00.876]         oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, 
  [11:21:00.876]             init = .init)
  [11:21:00.876]         return(invisible(oldStack))
  [11:21:00.876]     }
  [11:21:00.876]     if (is.language(strategy)) {
  [11:21:00.876]         first <- as.list(strategy)[[1]]
  [11:21:00.876]         if (is.symbol(first)) {
  [11:21:00.876]             if (is.call(strategy)) {
  [11:21:00.876]                 first <- get(as.character(first), mode = "function", 
  [11:21:00.876]                   envir = parent.frame(), inherits = TRUE)
  [11:21:00.876]             }
  [11:21:00.876]             else {
  [11:21:00.876]                 first <- eval(first, envir = parent.frame(), 
  [11:21:00.876]                   enclos = baseenv())
  [11:21:00.876]             }
  [11:21:00.876]             if (is.list(first)) {
  [11:21:00.876]                 strategies <- first
  [11:21:00.876]                 res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, 
  [11:21:00.876]                   .init = .init)
  [11:21:00.876]                 return(invisible(res))
  [11:21:00.876]             }
  [11:21:00.876]             if (is.function(first) && !inherits(first, "future")) {
  [11:21:00.876]                 strategies <- eval(strategy, envir = parent.frame(), 
  [11:21:00.876]                   enclos = baseenv())
  [11:21:00.876]                 if (is.list(strategies)) {
  [11:21:00.876]                   for (kk in seq_along(strategies)) {
  [11:21:00.876]                     strategy_kk <- strategies[[kk]]
  [11:21:00.876]                     if (is.character(strategy_kk)) {
  [11:21:00.876]                       strategy_kk <- tweak(strategy_kk, penvir = parent.frame())
  [11:21:00.876]                       strategies[[kk]] <- strategy_kk
  [11:21:00.876]                     }
  [11:21:00.876]                   }
  [11:21:00.876]                   newStack <- strategies
  [11:21:00.876]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:00.876]                     length(newStack) >= 1L)
  [11:21:00.876]                 }
  [11:21:00.876]                 else if (is.function(strategies) && !inherits(strategies, 
  [11:21:00.876]                   "future")) {
  [11:21:00.876]                   strategies <- list(strategies)
  [11:21:00.876]                   newStack <- strategies
  [11:21:00.876]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:00.876]                     length(newStack) >= 1L)
  [11:21:00.876]                 }
  [11:21:00.876]             }
  [11:21:00.876]         }
  [11:21:00.876]     }
  [11:21:00.876]     if (is.null(newStack)) {
  [11:21:00.876]         if (is.symbol(strategy)) {
  [11:21:00.876]             strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:00.876]                 enclos = baseenv())
  [11:21:00.876]         }
  [11:21:00.876]         else if (is.language(strategy)) {
  [11:21:00.876]             strategyT <- as.list(strategy)
  [11:21:00.876]             if (strategyT[[1]] == as.symbol("tweak")) {
  [11:21:00.876]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:00.876]                   enclos = baseenv())
  [11:21:00.876]             }
  [11:21:00.876]             else {
  [11:21:00.876]                 isSymbol <- sapply(strategyT, FUN = is.symbol)
  [11:21:00.876]                 if (!all(isSymbol)) {
  [11:21:00.876]                   targs <- c(targs, strategyT[-1L])
  [11:21:00.876]                   strategy <- strategyT[[1L]]
  [11:21:00.876]                 }
  [11:21:00.876]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:00.876]                   enclos = baseenv())
  [11:21:00.876]             }
  [11:21:00.876]         }
  [11:21:00.876]         args <- c(list(strategy), targs, penvir = parent.frame())
  [11:21:00.876]         tstrategy <- do.call(tweak, args = args)
  [11:21:00.876]         newStack <- list(tstrategy)
  [11:21:00.876]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:00.876]             1L)
  [11:21:00.876]     }
  [11:21:00.876]     if (!is.null(.call)) {
  [11:21:00.876]         call <- if (isTRUE(.call)) 
  [11:21:00.876]             sys.call()
  [11:21:00.876]         else .call
  [11:21:00.876]         for (kk in seq_along(newStack)) {
  [11:21:00.876]             strategy <- newStack[[kk]]
  [11:21:00.876]             if (!is.null(attr(strategy, "call", exact = TRUE))) 
  [11:21:00.876]                 next
  [11:21:00.876]             attr(strategy, "call") <- call
  [11:21:00.876]             newStack[[kk]] <- strategy
  [11:21:00.876]         }
  [11:21:00.876]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:00.876]             1L)
  [11:21:00.876]     }
  [11:21:00.876]     oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, 
  [11:21:00.876]         init = .init)
  [11:21:00.876]     invisible(oldStack)
  [11:21:00.876] }
  [11:21:00.876] <bytecode: 0x0000000007c91b08>
  [11:21:00.876] <environment: 0x0000000007cb61c0>
  List of 1
   $ y:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  List of 1
   $ y:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  - future_lapply(x, FUN = base::vector, ...) ...
  List of 1
   $ x:List of 3
    ..$ a: chr "integer"
    ..$ c: chr "character"
    ..$ c: chr "list"
  List of 1
   $ y0:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  - plan('batchtools_local') ...
  [11:21:09.144] function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, 
  [11:21:09.144]     .call = TRUE, .cleanup = TRUE, .init = TRUE) 
  [11:21:09.144] {
  [11:21:09.144]     if (substitute) 
  [11:21:09.144]         strategy <- substitute(strategy)
  [11:21:09.144]     if (is.logical(.skip)) 
  [11:21:09.144]         stop_if_not(length(.skip) == 1L, !is.na(.skip))
  [11:21:09.144]     if (is.logical(.call)) 
  [11:21:09.144]         stop_if_not(length(.call) == 1L, !is.na(.call))
  [11:21:09.144]     if (is.null(strategy) || identical(strategy, "next")) {
  [11:21:09.144]         strategy <- stack[[1L]]
  [11:21:09.144]         if (!inherits(strategy, "FutureStrategy")) {
  [11:21:09.144]             class(strategy) <- c("FutureStrategy", class(strategy))
  [11:21:09.144]         }
  [11:21:09.144]         stop_if_not(is.function(strategy))
  [11:21:09.144]         return(strategy)
  [11:21:09.144]     }
  [11:21:09.144]     else if (identical(strategy, "default")) {
  [11:21:09.144]         strategy <- getOption("future.plan", sequential)
  [11:21:09.144]     }
  [11:21:09.144]     else if (identical(strategy, "list")) {
  [11:21:09.144]         return(stack)
  [11:21:09.144]     }
  [11:21:09.144]     else if (identical(strategy, "reset")) {
  [11:21:09.144]         stack <<- defaultStack
  [11:21:09.144]         if (.cleanup) 
  [11:21:09.144]             plan_cleanup()
  [11:21:09.144]         return(stack)
  [11:21:09.144]     }
  [11:21:09.144]     else if (identical(strategy, "pop")) {
  [11:21:09.144]         oldStack <- stack
  [11:21:09.144]         stack <<- stack[-1L]
  [11:21:09.144]         if (length(stack) == 0L) 
  [11:21:09.144]             stack <<- defaultStack
  [11:21:09.144]         return(oldStack)
  [11:21:09.144]     }
  [11:21:09.144]     oldStack <- stack
  [11:21:09.144]     newStack <- NULL
  [11:21:09.144]     targs <- list(...)
  [11:21:09.144]     if (is.function(strategy)) {
  [11:21:09.144]         strategy <- list(strategy)
  [11:21:09.144]     }
  [11:21:09.144]     if (is.list(strategy)) {
  [11:21:09.144]         oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, 
  [11:21:09.144]             init = .init)
  [11:21:09.144]         return(invisible(oldStack))
  [11:21:09.144]     }
  [11:21:09.144]     if (is.language(strategy)) {
  [11:21:09.144]         first <- as.list(strategy)[[1]]
  [11:21:09.144]         if (is.symbol(first)) {
  [11:21:09.144]             if (is.call(strategy)) {
  [11:21:09.144]                 first <- get(as.character(first), mode = "function", 
  [11:21:09.144]                   envir = parent.frame(), inherits = TRUE)
  [11:21:09.144]             }
  [11:21:09.144]             else {
  [11:21:09.144]                 first <- eval(first, envir = parent.frame(), 
  [11:21:09.144]                   enclos = baseenv())
  [11:21:09.144]             }
  [11:21:09.144]             if (is.list(first)) {
  [11:21:09.144]                 strategies <- first
  [11:21:09.144]                 res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, 
  [11:21:09.144]                   .init = .init)
  [11:21:09.144]                 return(invisible(res))
  [11:21:09.144]             }
  [11:21:09.144]             if (is.function(first) && !inherits(first, "future")) {
  [11:21:09.144]                 strategies <- eval(strategy, envir = parent.frame(), 
  [11:21:09.144]                   enclos = baseenv())
  [11:21:09.144]                 if (is.list(strategies)) {
  [11:21:09.144]                   for (kk in seq_along(strategies)) {
  [11:21:09.144]                     strategy_kk <- strategies[[kk]]
  [11:21:09.144]                     if (is.character(strategy_kk)) {
  [11:21:09.144]                       strategy_kk <- tweak(strategy_kk, penvir = parent.frame())
  [11:21:09.144]                       strategies[[kk]] <- strategy_kk
  [11:21:09.144]                     }
  [11:21:09.144]                   }
  [11:21:09.144]                   newStack <- strategies
  [11:21:09.144]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:09.144]                     length(newStack) >= 1L)
  [11:21:09.144]                 }
  [11:21:09.144]                 else if (is.function(strategies) && !inherits(strategies, 
  [11:21:09.144]                   "future")) {
  [11:21:09.144]                   strategies <- list(strategies)
  [11:21:09.144]                   newStack <- strategies
  [11:21:09.144]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:09.144]                     length(newStack) >= 1L)
  [11:21:09.144]                 }
  [11:21:09.144]             }
  [11:21:09.144]         }
  [11:21:09.144]     }
  [11:21:09.144]     if (is.null(newStack)) {
  [11:21:09.144]         if (is.symbol(strategy)) {
  [11:21:09.144]             strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:09.144]                 enclos = baseenv())
  [11:21:09.144]         }
  [11:21:09.144]         else if (is.language(strategy)) {
  [11:21:09.144]             strategyT <- as.list(strategy)
  [11:21:09.144]             if (strategyT[[1]] == as.symbol("tweak")) {
  [11:21:09.144]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:09.144]                   enclos = baseenv())
  [11:21:09.144]             }
  [11:21:09.144]             else {
  [11:21:09.144]                 isSymbol <- sapply(strategyT, FUN = is.symbol)
  [11:21:09.144]                 if (!all(isSymbol)) {
  [11:21:09.144]                   targs <- c(targs, strategyT[-1L])
  [11:21:09.144]                   strategy <- strategyT[[1L]]
  [11:21:09.144]                 }
  [11:21:09.144]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:09.144]                   enclos = baseenv())
  [11:21:09.144]             }
  [11:21:09.144]         }
  [11:21:09.144]         args <- c(list(strategy), targs, penvir = parent.frame())
  [11:21:09.144]         tstrategy <- do.call(tweak, args = args)
  [11:21:09.144]         newStack <- list(tstrategy)
  [11:21:09.144]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:09.144]             1L)
  [11:21:09.144]     }
  [11:21:09.144]     if (!is.null(.call)) {
  [11:21:09.144]         call <- if (isTRUE(.call)) 
  [11:21:09.144]             sys.call()
  [11:21:09.144]         else .call
  [11:21:09.144]         for (kk in seq_along(newStack)) {
  [11:21:09.144]             strategy <- newStack[[kk]]
  [11:21:09.144]             if (!is.null(attr(strategy, "call", exact = TRUE))) 
  [11:21:09.144]                 next
  [11:21:09.144]             attr(strategy, "call") <- call
  [11:21:09.144]             newStack[[kk]] <- strategy
  [11:21:09.144]         }
  [11:21:09.144]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:09.144]             1L)
  [11:21:09.144]     }
  [11:21:09.144]     oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, 
  [11:21:09.144]         init = .init)
  [11:21:09.144]     invisible(oldStack)
  [11:21:09.144] }
  [11:21:09.144] <bytecode: 0x0000000007c91b08>
  [11:21:09.144] <environment: 0x0000000007cb61c0>
  List of 1
   $ y:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  List of 1
   $ y:List of 3
    ..$ a: int [1:2] 0 0
    ..$ c: chr [1:2] "" ""
    ..$ c:List of 2
    .. ..$ : NULL
    .. ..$ : NULL
  - future_lapply(x, FUN = future:::hpaste, ...) ...
  List of 1
   $ x:List of 1
    ..$ a: Named chr [1:101] "hello" "1" "2" "3" ...
    .. ..- attr(*, "names")= chr [1:101] "" "b1" "b2" "b3" ...
  List of 1
   $ y0:List of 1
    ..$ a: chr "hello; 1; 2; ...; 100"
  - plan('batchtools_local') ...
  [11:21:17.304] function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, 
  [11:21:17.304]     .call = TRUE, .cleanup = TRUE, .init = TRUE) 
  [11:21:17.304] {
  [11:21:17.304]     if (substitute) 
  [11:21:17.304]         strategy <- substitute(strategy)
  [11:21:17.304]     if (is.logical(.skip)) 
  [11:21:17.304]         stop_if_not(length(.skip) == 1L, !is.na(.skip))
  [11:21:17.304]     if (is.logical(.call)) 
  [11:21:17.304]         stop_if_not(length(.call) == 1L, !is.na(.call))
  [11:21:17.304]     if (is.null(strategy) || identical(strategy, "next")) {
  [11:21:17.304]         strategy <- stack[[1L]]
  [11:21:17.304]         if (!inherits(strategy, "FutureStrategy")) {
  [11:21:17.304]             class(strategy) <- c("FutureStrategy", class(strategy))
  [11:21:17.304]         }
  [11:21:17.304]         stop_if_not(is.function(strategy))
  [11:21:17.304]         return(strategy)
  [11:21:17.304]     }
  [11:21:17.304]     else if (identical(strategy, "default")) {
  [11:21:17.304]         strategy <- getOption("future.plan", sequential)
  [11:21:17.304]     }
  [11:21:17.304]     else if (identical(strategy, "list")) {
  [11:21:17.304]         return(stack)
  [11:21:17.304]     }
  [11:21:17.304]     else if (identical(strategy, "reset")) {
  [11:21:17.304]         stack <<- defaultStack
  [11:21:17.304]         if (.cleanup) 
  [11:21:17.304]             plan_cleanup()
  [11:21:17.304]         return(stack)
  [11:21:17.304]     }
  [11:21:17.304]     else if (identical(strategy, "pop")) {
  [11:21:17.304]         oldStack <- stack
  [11:21:17.304]         stack <<- stack[-1L]
  [11:21:17.304]         if (length(stack) == 0L) 
  [11:21:17.304]             stack <<- defaultStack
  [11:21:17.304]         return(oldStack)
  [11:21:17.304]     }
  [11:21:17.304]     oldStack <- stack
  [11:21:17.304]     newStack <- NULL
  [11:21:17.304]     targs <- list(...)
  [11:21:17.304]     if (is.function(strategy)) {
  [11:21:17.304]         strategy <- list(strategy)
  [11:21:17.304]     }
  [11:21:17.304]     if (is.list(strategy)) {
  [11:21:17.304]         oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, 
  [11:21:17.304]             init = .init)
  [11:21:17.304]         return(invisible(oldStack))
  [11:21:17.304]     }
  [11:21:17.304]     if (is.language(strategy)) {
  [11:21:17.304]         first <- as.list(strategy)[[1]]
  [11:21:17.304]         if (is.symbol(first)) {
  [11:21:17.304]             if (is.call(strategy)) {
  [11:21:17.304]                 first <- get(as.character(first), mode = "function", 
  [11:21:17.304]                   envir = parent.frame(), inherits = TRUE)
  [11:21:17.304]             }
  [11:21:17.304]             else {
  [11:21:17.304]                 first <- eval(first, envir = parent.frame(), 
  [11:21:17.304]                   enclos = baseenv())
  [11:21:17.304]             }
  [11:21:17.304]             if (is.list(first)) {
  [11:21:17.304]                 strategies <- first
  [11:21:17.304]                 res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, 
  [11:21:17.304]                   .init = .init)
  [11:21:17.304]                 return(invisible(res))
  [11:21:17.304]             }
  [11:21:17.304]             if (is.function(first) && !inherits(first, "future")) {
  [11:21:17.304]                 strategies <- eval(strategy, envir = parent.frame(), 
  [11:21:17.304]                   enclos = baseenv())
  [11:21:17.304]                 if (is.list(strategies)) {
  [11:21:17.304]                   for (kk in seq_along(strategies)) {
  [11:21:17.304]                     strategy_kk <- strategies[[kk]]
  [11:21:17.304]                     if (is.character(strategy_kk)) {
  [11:21:17.304]                       strategy_kk <- tweak(strategy_kk, penvir = parent.frame())
  [11:21:17.304]                       strategies[[kk]] <- strategy_kk
  [11:21:17.304]                     }
  [11:21:17.304]                   }
  [11:21:17.304]                   newStack <- strategies
  [11:21:17.304]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:17.304]                     length(newStack) >= 1L)
  [11:21:17.304]                 }
  [11:21:17.304]                 else if (is.function(strategies) && !inherits(strategies, 
  [11:21:17.304]                   "future")) {
  [11:21:17.304]                   strategies <- list(strategies)
  [11:21:17.304]                   newStack <- strategies
  [11:21:17.304]                   stop_if_not(!is.null(newStack), is.list(newStack), 
  [11:21:17.304]                     length(newStack) >= 1L)
  [11:21:17.304]                 }
  [11:21:17.304]             }
  [11:21:17.304]         }
  [11:21:17.304]     }
  [11:21:17.304]     if (is.null(newStack)) {
  [11:21:17.304]         if (is.symbol(strategy)) {
  [11:21:17.304]             strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:17.304]                 enclos = baseenv())
  [11:21:17.304]         }
  [11:21:17.304]         else if (is.language(strategy)) {
  [11:21:17.304]             strategyT <- as.list(strategy)
  [11:21:17.304]             if (strategyT[[1]] == as.symbol("tweak")) {
  [11:21:17.304]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:17.304]                   enclos = baseenv())
  [11:21:17.304]             }
  [11:21:17.304]             else {
  [11:21:17.304]                 isSymbol <- sapply(strategyT, FUN = is.symbol)
  [11:21:17.304]                 if (!all(isSymbol)) {
  [11:21:17.304]                   targs <- c(targs, strategyT[-1L])
  [11:21:17.304]                   strategy <- strategyT[[1L]]
  [11:21:17.304]                 }
  [11:21:17.304]                 strategy <- eval(strategy, envir = parent.frame(), 
  [11:21:17.304]                   enclos = baseenv())
  [11:21:17.304]             }
  [11:21:17.304]         }
  [11:21:17.304]         args <- c(list(strategy), targs, penvir = parent.frame())
  [11:21:17.304]         tstrategy <- do.call(tweak, args = args)
  [11:21:17.304]         newStack <- list(tstrategy)
  [11:21:17.304]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:17.304]             1L)
  [11:21:17.304]     }
  [11:21:17.304]     if (!is.null(.call)) {
  [11:21:17.304]         call <- if (isTRUE(.call)) 
  [11:21:17.304]             sys.call()
  [11:21:17.304]         else .call
  [11:21:17.304]         for (kk in seq_along(newStack)) {
  [11:21:17.304]             strategy <- newStack[[kk]]
  [11:21:17.304]             if (!is.null(attr(strategy, "call", exact = TRUE))) 
  [11:21:17.304]                 next
  [11:21:17.304]             attr(strategy, "call") <- call
  [11:21:17.304]             newStack[[kk]] <- strategy
  [11:21:17.304]         }
  [11:21:17.304]         stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= 
  [11:21:17.304]             1L)
  [11:21:17.304]     }
  [11:21:17.304]     oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, 
  [11:21:17.304]         init = .init)
  [11:21:17.304]     invisible(oldStack)
  [11:21:17.304] }
  [11:21:17.304] <bytecode: 0x0000000007c91b08>
  [11:21:17.304] <environment: 0x0000000007cb61c0>
  List of 1
   $ y:List of 1
    ..$ a: chr "hello; 1; 2; ...; 100"
  List of 1
   $ y:List of 1
    ..$ a: chr "hello; 1; 2; ...; 100"
  - future_lapply(x, FUN = listenv::listenv, ...) ...
  $a
  A 'listenv' vector with 1 element ('A').
  
  $b
  A 'listenv' vector with 2 elements ('A', 'B').
  
  List of 1
   $ y0:List of 2
    ..$ a: Named chr "A"
    .. ..- attr(*, "names")= chr "A"
    ..$ b: Named chr [1:2] "A" "B"
    .. ..- attr(*, "names")= chr [1:2] "A" "B"
  - plan('batchtools_local') ...
  List of 1
   $ y:List of 2
    ..$ a: Named chr "A"
    .. ..- attr(*, "names")= chr "A"
    ..$ b: Named chr [1:2] "A" "B"
    .. ..- attr(*, "names")= chr [1:2] "A" "B"
  List of 1
   $ y:List of 2
    ..$ a: Named chr "A"
    .. ..- attr(*, "names")= chr "A"
    ..$ b: Named chr [1:2] "A" "B"
    .. ..- attr(*, "names")= chr [1:2] "A" "B"
  - future_lapply(x, FUN, ...) for large length(x) ...
  - future_lapply() with global in non-attached package ...
  Warning in file(con, "r") :
    cannot open file 'D:/temp/Rtmpwd7ORd/.future/20220123_112101-wd7ORd/future_lapply-1_618733105/logs/job5af8f054a220c6975a5ade57d9c1f411.log': No such file or directory
  Error in file(con, "r") : cannot open the connection
  Calls: future_lapply ... getLog -> extractLog -> readLog -> readLines -> file
  Execution halted
  Warning in file(con, "r") :
    cannot open file 'D:/temp/Rtmpwd7ORd/.future/20220123_112101-wd7ORd/future_lapply-1_618733105/logs/job5af8f054a220c6975a5ade57d9c1f411.log': No such file or directory
  Error in file(con, "r") : cannot open the connection
Running the tests in 'tests/zzz.onUnload.R' failed.
Complete output:
  > source("incl/start.R")
  Error in library("future.batchtools") : 
    there is no package called 'future.batchtools'
  Calls: source -> withVisible -> eval -> eval -> library
  Execution halted