CRAN Package Check Results for Package future.batchtools

Last updated on 2022-01-26 19:50:33 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.10.0 5.32 289.37 294.69 OK
r-devel-linux-x86_64-debian-gcc 0.10.0 3.97 214.02 217.99 OK
r-devel-linux-x86_64-fedora-clang 0.10.0 332.55 NOTE
r-devel-linux-x86_64-fedora-gcc 0.10.0 355.55 OK
r-devel-windows-x86_64-new-UL 0.10.0 107.00 389.00 496.00 OK
r-devel-windows-x86_64-new-TK 0.10.0 OK
r-patched-linux-x86_64 0.10.0 7.39 256.13 263.52 OK
r-release-linux-x86_64 0.10.0 3.70 257.33 261.03 OK
r-release-macos-arm64 0.10.0 OK
r-release-macos-x86_64 0.10.0 OK
r-release-windows-ix86+x86_64 0.10.0 11.00 330.00 341.00 ERROR
r-oldrel-macos-x86_64 0.10.0 OK
r-oldrel-windows-ix86+x86_64 0.10.0 11.00 336.00 347.00 OK

Check Details

Version: 0.10.0
Check: Rd cross-references
Result: NOTE
    Undeclared package ‘globals’ in Rd xrefs
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 0.10.0
Check: tests
Result: ERROR
     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
Flavor: r-release-windows-ix86+x86_64