Last updated on 2025-04-20 09:49:29 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 1.0.2 | 3.42 | 135.87 | 139.29 | OK | |
| r-devel-linux-x86_64-debian-gcc | 1.0.2 | 2.12 | 107.62 | 109.74 | OK | |
| r-devel-linux-x86_64-fedora-clang | 1.0.2 | 233.43 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 1.0.2 | 228.34 | OK | |||
| r-devel-windows-x86_64 | 1.0.2 | 4.00 | 313.00 | 317.00 | ERROR | |
| r-patched-linux-x86_64 | 1.0.2 | 2.77 | 130.75 | 133.52 | OK | |
| r-release-linux-x86_64 | 1.0.2 | 3.31 | 131.09 | 134.40 | OK | |
| r-release-macos-arm64 | 1.0.2 | 116.00 | OK | |||
| r-release-macos-x86_64 | 1.0.2 | 176.00 | OK | |||
| r-release-windows-x86_64 | 1.0.2 | 5.00 | 305.00 | 310.00 | ERROR | |
| r-oldrel-macos-arm64 | 1.0.2 | 110.00 | OK | |||
| r-oldrel-macos-x86_64 | 1.0.2 | 281.00 | OK | |||
| r-oldrel-windows-x86_64 | 1.0.2 | 5.00 | 371.00 | 376.00 | ERROR |
Version: 1.0.2
Check: tests
Result: ERROR
Running 'foreach_dofuture,cluster-missing-doFuture-pkg.R' [62s]
Running 'foreach_dofuture,errors.R' [10s]
Running 'foreach_dofuture,globals.R' [7s]
Running 'foreach_dofuture,nested_colon.R' [14s]
Running 'foreach_dofuture,nested_dofuture.R' [16s]
Running 'foreach_dofuture,rng.R' [4s]
Running 'foreach_dofuture.R' [3s]
Running 'foreach_dopar,cluster-missing-doFuture-pkg.R' [62s]
Running 'foreach_dopar,doRNG,dopar.R' [3s]
Running 'foreach_dopar,doRNG,dorng.R' [6s]
Running 'foreach_dopar,errors.R' [8s]
Running 'foreach_dopar,globals.R' [7s]
Running 'foreach_dopar,nested_colon.R' [13s]
Running 'foreach_dopar,nested_dopar.R' [16s]
Running 'foreach_dopar,options-for-export.R' [5s]
Running 'foreach_dopar.R' [3s]
Running 'makeChunks.R' [4s]
Running 'options,nested.R' [4s]
Running 'registerDoFuture.R' [2s]
Running 'times.R' [2s]
Running 'utils.R' [1s]
Running 'withDoRNG.R' [4s]
Running the tests in 'tests/foreach_dofuture,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R Under development (unstable) (2025-04-16 r88149 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
LAPACK version 3.12.1
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.6.0 parallelly_1.43.0 tools_4.6.0
[4] parallel_4.6.0 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_17_01_50_00_8240/RtmpA5Nt7O/RLIBS_2c6dc3ecf4a04', 'D:/RCompile/recent/R/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.6/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[05:58:35.402] doFuture2() ...
[05:58:35.457] Number of chunks: 1
[05:58:35.458] Number of futures (= number of chunks): 1
[05:58:35.458] seed = FALSE
[05:58:35.459] NULL
[05:58:35.462] seed = FALSE
[05:58:35.462] seed = FALSE
[05:58:35.463] - %dofuture% R expression:
[05:58:35.463] ii
[05:58:35.463] - foreach iterator arguments: [1] 'ii'
[05:58:35.464] - dummy globals (as locals): [1] 'ii'
[05:58:35.464] - R expression (map-reduce expression adjusted for RNG):
[05:58:35.465] {
[05:58:35.465] NULL
[05:58:35.465] "# doFuture():::doFuture2(): process chunk of elements"
[05:58:35.465] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[05:58:35.465] ...future.x_jj <- ...future.x_ii[[jj]]
[05:58:35.465] {
[05:58:35.465] NULL
[05:58:35.465] ii <- NULL
[05:58:35.465] }
[05:58:35.465] ...future.env <- environment()
[05:58:35.465] local({
[05:58:35.465] for (name in names(...future.x_jj)) {
[05:58:35.465] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[05:58:35.465] inherits = FALSE)
[05:58:35.465] }
[05:58:35.465] })
[05:58:35.465] NULL
[05:58:35.465] tryCatch(ii, error = identity)
[05:58:35.465] })
[05:58:35.465] }
[05:58:35.465] - identifying globals and packages ...
[05:58:35.465] - Argument 'globals':
[05:58:35.465] logi TRUE
[05:58:35.465] - attr(*, "add")= chr "...future.x_ii"
[05:58:35.465] - attr(*, "ignore")= chr "ii"
[05:58:35.468] - R expression (map-reduce expression searched for globals):
[05:58:35.468] {
[05:58:35.468] NULL
[05:58:35.468] "# doFuture():::doFuture2(): process chunk of elements"
[05:58:35.468] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[05:58:35.468] ...future.x_jj <- ...future.x_ii[[jj]]
[05:58:35.468] {
[05:58:35.468] NULL
[05:58:35.468] ii <- NULL
[05:58:35.468] }
[05:58:35.468] ...future.env <- environment()
[05:58:35.468] local({
[05:58:35.468] for (name in names(...future.x_jj)) {
[05:58:35.468] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[05:58:35.468] inherits = FALSE)
[05:58:35.468] }
[05:58:35.468] })
[05:58:35.468] NULL
[05:58:35.468] tryCatch(ii, error = identity)
[05:58:35.468] })
[05:58:35.468] }
[05:58:35.479] - R expression (%dofuture% expression searched for globals):
[05:58:35.479] ii
[05:58:35.480] - Globals in %dofuture% R expression not in map-reduce expression:
[05:58:35.480] - Appending 0 globals only found in the vanilla %dofuture% expression:
[05:58:35.481] - globals: [1] '...future.x_ii'
[05:58:35.481] List of 1
[05:58:35.481] $ ...future.x_ii: num 42
[05:58:35.481] - attr(*, "where")=List of 1
[05:58:35.481] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[05:58:35.481] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[05:58:35.481] - attr(*, "resolved")= logi FALSE
[05:58:35.481] - attr(*, "total_size")= num 39
[05:58:35.485] - packages: [1] 'doFuture'
[05:58:35.486] - identifying globals and packages ... DONE
[05:58:35.486] Launching 1 futures (chunks) ...
[05:58:35.486] Chunk #1 of 1 ...
[05:58:35.487] - Finding globals in 'args_list' for chunk #1 ...
[05:58:35.488]
[05:58:35.488]
[05:58:35.489] - Finding globals in 'args_list' for chunk #1 ... DONE
[05:58:35.489] - seeds: <none>
[05:58:35.498] Chunk #1 of 1 ... DONE
[05:58:35.498] Launching 1 futures (chunks) ... DONE
[05:58:35.499] - resolving futures
[05:58:35.499] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture2-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: e608a6df73248bb4fdaf2045a8a2a259-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture2-1'
Expression:
{
NULL
"# doFuture():::doFuture2(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
NULL
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: e608a6df73248bb4fdaf2045a8a2a259
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Running the tests in 'tests/foreach_dopar,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R Under development (unstable) (2025-04-16 r88149 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
LAPACK version 3.12.1
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.6.0 parallelly_1.43.0 tools_4.6.0
[4] parallel_4.6.0 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> registerDoFuture()
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_17_01_50_00_8240/RtmpA5Nt7O/RLIBS_2c6dc3ecf4a04', 'D:/RCompile/recent/R/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.6/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[06:00:31.863] doFuture() ...
[06:00:31.866] - dummy globals (as locals): [1] 'ii'
[06:00:31.866] - R expression:
[06:00:31.866] {
[06:00:31.866] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:00:31.866] "# also in nested calls "
[06:00:31.866] doFuture::registerDoFuture()
[06:00:31.866] "# doFuture():::doFuture(): process chunk of elements"
[06:00:31.866] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:00:31.866] ...future.x_jj <- ...future.x_ii[[jj]]
[06:00:31.866] {
[06:00:31.866] NULL
[06:00:31.866] ii <- NULL
[06:00:31.866] }
[06:00:31.866] ...future.env <- environment()
[06:00:31.866] local({
[06:00:31.866] for (name in names(...future.x_jj)) {
[06:00:31.866] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:00:31.866] inherits = FALSE)
[06:00:31.866] }
[06:00:31.866] })
[06:00:31.866] tryCatch(ii, error = identity)
[06:00:31.866] })
[06:00:31.866] }
[06:00:31.867] - identifying globals and packages ...
[06:00:31.882] List of 1
[06:00:31.882] $ ...future.x_ii: NULL
[06:00:31.882] - attr(*, "where")=List of 1
[06:00:31.882] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:00:31.882] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:00:31.882] - attr(*, "resolved")= logi FALSE
[06:00:31.882] - attr(*, "total_size")= num 27
[06:00:31.892] - R expression:
[06:00:31.892] {
[06:00:31.892] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:00:31.892] "# also in nested calls "
[06:00:31.892] doFuture::registerDoFuture()
[06:00:31.892] "# doFuture():::doFuture(): process chunk of elements"
[06:00:31.892] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:00:31.892] ...future.x_jj <- ...future.x_ii[[jj]]
[06:00:31.892] {
[06:00:31.892] NULL
[06:00:31.892] ii <- NULL
[06:00:31.892] }
[06:00:31.892] ...future.env <- environment()
[06:00:31.892] local({
[06:00:31.892] for (name in names(...future.x_jj)) {
[06:00:31.892] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:00:31.892] inherits = FALSE)
[06:00:31.892] }
[06:00:31.892] })
[06:00:31.892] tryCatch(ii, error = identity)
[06:00:31.892] })
[06:00:31.892] }
[06:00:31.893] - globals: [1] '...future.x_ii'
[06:00:31.893] List of 1
[06:00:31.893] $ ...future.x_ii: NULL
[06:00:31.893] - attr(*, "where")=List of 1
[06:00:31.893] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:00:31.893] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:00:31.893] - attr(*, "resolved")= logi FALSE
[06:00:31.893] - attr(*, "total_size")= num 27
[06:00:31.898] - packages: [1] 'doFuture'
[06:00:31.898] - identifying globals and packages ... DONE
[06:00:31.951] Number of chunks: 1
[06:00:31.952] Number of futures (= number of chunks): 1
[06:00:31.952] Launching 1 futures (chunks) ...
[06:00:31.952] Chunk #1 of 1 ...
[06:00:31.952] - Finding globals in 'args_list' chunk #1 ...
[06:00:31.953]
[06:00:31.954]
[06:00:31.954] - Finding globals in 'args_list' for chunk #1 ... DONE
[06:00:31.961] Chunk #1 of 1 ... DONE
[06:00:31.961] Launching 1 futures (chunks) ... DONE
[06:00:31.961] - resolving futures
[06:00:31.962] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: a62247df224483150ce2e803eb1accfe-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture-1'
Expression:
{
"# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
"# also in nested calls "
doFuture::registerDoFuture()
"# doFuture():::doFuture(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: a62247df224483150ce2e803eb1accfe
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Flavor: r-devel-windows-x86_64
Version: 1.0.2
Check: tests
Result: ERROR
Running 'foreach_dofuture,cluster-missing-doFuture-pkg.R' [62s]
Running 'foreach_dofuture,errors.R' [10s]
Running 'foreach_dofuture,globals.R' [7s]
Running 'foreach_dofuture,nested_colon.R' [13s]
Running 'foreach_dofuture,nested_dofuture.R' [14s]
Running 'foreach_dofuture,rng.R' [4s]
Running 'foreach_dofuture.R' [3s]
Running 'foreach_dopar,cluster-missing-doFuture-pkg.R' [62s]
Running 'foreach_dopar,doRNG,dopar.R' [2s]
Running 'foreach_dopar,doRNG,dorng.R' [5s]
Running 'foreach_dopar,errors.R' [7s]
Running 'foreach_dopar,globals.R' [7s]
Running 'foreach_dopar,nested_colon.R' [12s]
Running 'foreach_dopar,nested_dopar.R' [16s]
Running 'foreach_dopar,options-for-export.R' [4s]
Running 'foreach_dopar.R' [3s]
Running 'makeChunks.R' [4s]
Running 'options,nested.R' [3s]
Running 'registerDoFuture.R' [2s]
Running 'times.R' [2s]
Running 'utils.R' [1s]
Running 'withDoRNG.R' [4s]
Running the tests in 'tests/foreach_dofuture,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R version 4.5.0 (2025-04-11 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
LAPACK version 3.12.1
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.5.0 parallelly_1.43.0 tools_4.5.0
[4] parallel_4.5.0 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_19_01_50_00_15476/RtmpsrYCxV/RLIBS_30ba850314ff', 'D:/RCompile/recent/R-4.5.0/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.5/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[06:02:33.722] doFuture2() ...
[06:02:33.778] Number of chunks: 1
[06:02:33.778] Number of futures (= number of chunks): 1
[06:02:33.779] seed = FALSE
[06:02:33.779] NULL
[06:02:33.782] seed = FALSE
[06:02:33.782] seed = FALSE
[06:02:33.782] - %dofuture% R expression:
[06:02:33.783] ii
[06:02:33.783] - foreach iterator arguments: [1] 'ii'
[06:02:33.783] - dummy globals (as locals): [1] 'ii'
[06:02:33.784] - R expression (map-reduce expression adjusted for RNG):
[06:02:33.784] {
[06:02:33.784] NULL
[06:02:33.784] "# doFuture():::doFuture2(): process chunk of elements"
[06:02:33.784] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:02:33.784] ...future.x_jj <- ...future.x_ii[[jj]]
[06:02:33.784] {
[06:02:33.784] NULL
[06:02:33.784] ii <- NULL
[06:02:33.784] }
[06:02:33.784] ...future.env <- environment()
[06:02:33.784] local({
[06:02:33.784] for (name in names(...future.x_jj)) {
[06:02:33.784] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:02:33.784] inherits = FALSE)
[06:02:33.784] }
[06:02:33.784] })
[06:02:33.784] NULL
[06:02:33.784] tryCatch(ii, error = identity)
[06:02:33.784] })
[06:02:33.784] }
[06:02:33.784] - identifying globals and packages ...
[06:02:33.785] - Argument 'globals':
[06:02:33.785] logi TRUE
[06:02:33.785] - attr(*, "add")= chr "...future.x_ii"
[06:02:33.785] - attr(*, "ignore")= chr "ii"
[06:02:33.788] - R expression (map-reduce expression searched for globals):
[06:02:33.788] {
[06:02:33.788] NULL
[06:02:33.788] "# doFuture():::doFuture2(): process chunk of elements"
[06:02:33.788] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:02:33.788] ...future.x_jj <- ...future.x_ii[[jj]]
[06:02:33.788] {
[06:02:33.788] NULL
[06:02:33.788] ii <- NULL
[06:02:33.788] }
[06:02:33.788] ...future.env <- environment()
[06:02:33.788] local({
[06:02:33.788] for (name in names(...future.x_jj)) {
[06:02:33.788] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:02:33.788] inherits = FALSE)
[06:02:33.788] }
[06:02:33.788] })
[06:02:33.788] NULL
[06:02:33.788] tryCatch(ii, error = identity)
[06:02:33.788] })
[06:02:33.788] }
[06:02:33.801] - R expression (%dofuture% expression searched for globals):
[06:02:33.801] ii
[06:02:33.803] - Globals in %dofuture% R expression not in map-reduce expression:
[06:02:33.803] - Appending 0 globals only found in the vanilla %dofuture% expression:
[06:02:33.803] - globals: [1] '...future.x_ii'
[06:02:33.803] List of 1
[06:02:33.803] $ ...future.x_ii: num 42
[06:02:33.803] - attr(*, "where")=List of 1
[06:02:33.803] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:02:33.803] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:02:33.803] - attr(*, "resolved")= logi FALSE
[06:02:33.803] - attr(*, "total_size")= num 39
[06:02:33.808] - packages: [1] 'doFuture'
[06:02:33.808] - identifying globals and packages ... DONE
[06:02:33.808] Launching 1 futures (chunks) ...
[06:02:33.808] Chunk #1 of 1 ...
[06:02:33.809] - Finding globals in 'args_list' for chunk #1 ...
[06:02:33.809]
[06:02:33.810]
[06:02:33.810] - Finding globals in 'args_list' for chunk #1 ... DONE
[06:02:33.810] - seeds: <none>
[06:02:33.826] Chunk #1 of 1 ... DONE
[06:02:33.827] Launching 1 futures (chunks) ... DONE
[06:02:33.827] - resolving futures
[06:02:33.827] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture2-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: b0fed4fece7b9a92116d216e27708efc-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture2-1'
Expression:
{
NULL
"# doFuture():::doFuture2(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
NULL
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: b0fed4fece7b9a92116d216e27708efc
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Running the tests in 'tests/foreach_dopar,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R version 4.5.0 (2025-04-11 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
LAPACK version 3.12.1
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.5.0 parallelly_1.43.0 tools_4.5.0
[4] parallel_4.5.0 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> registerDoFuture()
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_19_01_50_00_15476/RtmpsrYCxV/RLIBS_30ba850314ff', 'D:/RCompile/recent/R-4.5.0/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.5/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[06:04:26.835] doFuture() ...
[06:04:26.837] - dummy globals (as locals): [1] 'ii'
[06:04:26.837] - R expression:
[06:04:26.837] {
[06:04:26.837] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:04:26.837] "# also in nested calls "
[06:04:26.837] doFuture::registerDoFuture()
[06:04:26.837] "# doFuture():::doFuture(): process chunk of elements"
[06:04:26.837] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:04:26.837] ...future.x_jj <- ...future.x_ii[[jj]]
[06:04:26.837] {
[06:04:26.837] NULL
[06:04:26.837] ii <- NULL
[06:04:26.837] }
[06:04:26.837] ...future.env <- environment()
[06:04:26.837] local({
[06:04:26.837] for (name in names(...future.x_jj)) {
[06:04:26.837] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:04:26.837] inherits = FALSE)
[06:04:26.837] }
[06:04:26.837] })
[06:04:26.837] tryCatch(ii, error = identity)
[06:04:26.837] })
[06:04:26.837] }
[06:04:26.838] - identifying globals and packages ...
[06:04:26.851] List of 1
[06:04:26.851] $ ...future.x_ii: NULL
[06:04:26.851] - attr(*, "where")=List of 1
[06:04:26.851] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:04:26.851] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:04:26.851] - attr(*, "resolved")= logi FALSE
[06:04:26.851] - attr(*, "total_size")= num 27
[06:04:26.860] - R expression:
[06:04:26.860] {
[06:04:26.860] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:04:26.860] "# also in nested calls "
[06:04:26.860] doFuture::registerDoFuture()
[06:04:26.860] "# doFuture():::doFuture(): process chunk of elements"
[06:04:26.860] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:04:26.860] ...future.x_jj <- ...future.x_ii[[jj]]
[06:04:26.860] {
[06:04:26.860] NULL
[06:04:26.860] ii <- NULL
[06:04:26.860] }
[06:04:26.860] ...future.env <- environment()
[06:04:26.860] local({
[06:04:26.860] for (name in names(...future.x_jj)) {
[06:04:26.860] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:04:26.860] inherits = FALSE)
[06:04:26.860] }
[06:04:26.860] })
[06:04:26.860] tryCatch(ii, error = identity)
[06:04:26.860] })
[06:04:26.860] }
[06:04:26.861] - globals: [1] '...future.x_ii'
[06:04:26.862] List of 1
[06:04:26.862] $ ...future.x_ii: NULL
[06:04:26.862] - attr(*, "where")=List of 1
[06:04:26.862] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:04:26.862] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:04:26.862] - attr(*, "resolved")= logi FALSE
[06:04:26.862] - attr(*, "total_size")= num 27
[06:04:26.866] - packages: [1] 'doFuture'
[06:04:26.866] - identifying globals and packages ... DONE
[06:04:26.917] Number of chunks: 1
[06:04:26.918] Number of futures (= number of chunks): 1
[06:04:26.918] Launching 1 futures (chunks) ...
[06:04:26.918] Chunk #1 of 1 ...
[06:04:26.919] - Finding globals in 'args_list' chunk #1 ...
[06:04:26.920]
[06:04:26.920]
[06:04:26.920] - Finding globals in 'args_list' for chunk #1 ... DONE
[06:04:26.928] Chunk #1 of 1 ... DONE
[06:04:26.928] Launching 1 futures (chunks) ... DONE
[06:04:26.928] - resolving futures
[06:04:26.928] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: f66d2198aea273bb7a34b590af381477-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture-1'
Expression:
{
"# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
"# also in nested calls "
doFuture::registerDoFuture()
"# doFuture():::doFuture(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: f66d2198aea273bb7a34b590af381477
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Flavor: r-release-windows-x86_64
Version: 1.0.2
Check: tests
Result: ERROR
Running 'foreach_dofuture,cluster-missing-doFuture-pkg.R' [63s]
Running 'foreach_dofuture,errors.R' [14s]
Running 'foreach_dofuture,globals.R' [10s]
Running 'foreach_dofuture,nested_colon.R' [19s]
Running 'foreach_dofuture,nested_dofuture.R' [20s]
Running 'foreach_dofuture,rng.R' [6s]
Running 'foreach_dofuture.R' [4s]
Running 'foreach_dopar,cluster-missing-doFuture-pkg.R' [63s]
Running 'foreach_dopar,doRNG,dopar.R' [3s]
Running 'foreach_dopar,doRNG,dorng.R' [8s]
Running 'foreach_dopar,errors.R' [11s]
Running 'foreach_dopar,globals.R' [10s]
Running 'foreach_dopar,nested_colon.R' [17s]
Running 'foreach_dopar,nested_dopar.R' [23s]
Running 'foreach_dopar,options-for-export.R' [7s]
Running 'foreach_dopar.R' [4s]
Running 'makeChunks.R' [6s]
Running 'options,nested.R' [5s]
Running 'registerDoFuture.R' [3s]
Running 'times.R' [3s]
Running 'utils.R' [1s]
Running 'withDoRNG.R' [5s]
Running the tests in 'tests/foreach_dofuture,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R version 4.4.3 (2025-02-28 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.4.3 parallelly_1.43.0 tools_4.4.3
[4] parallel_4.4.3 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_19_01_50_00_15476/RtmpsVaBxi/RLIBS_206cc7ab72aa9', 'D:/RCompile/recent/R-4.4.3/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.4/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dofuture% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[06:48:57.245] doFuture2() ...
[06:48:57.342] Number of chunks: 1
[06:48:57.343] Number of futures (= number of chunks): 1
[06:48:57.343] seed = FALSE
[06:48:57.344] NULL
[06:48:57.349] seed = FALSE
[06:48:57.349] seed = FALSE
[06:48:57.350] - %dofuture% R expression:
[06:48:57.350] ii
[06:48:57.351] - foreach iterator arguments: [1] 'ii'
[06:48:57.351] - dummy globals (as locals): [1] 'ii'
[06:48:57.352] - R expression (map-reduce expression adjusted for RNG):
[06:48:57.352] {
[06:48:57.352] NULL
[06:48:57.352] "# doFuture():::doFuture2(): process chunk of elements"
[06:48:57.352] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:48:57.352] ...future.x_jj <- ...future.x_ii[[jj]]
[06:48:57.352] {
[06:48:57.352] NULL
[06:48:57.352] ii <- NULL
[06:48:57.352] }
[06:48:57.352] ...future.env <- environment()
[06:48:57.352] local({
[06:48:57.352] for (name in names(...future.x_jj)) {
[06:48:57.352] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:48:57.352] inherits = FALSE)
[06:48:57.352] }
[06:48:57.352] })
[06:48:57.352] NULL
[06:48:57.352] tryCatch(ii, error = identity)
[06:48:57.352] })
[06:48:57.352] }
[06:48:57.353] - identifying globals and packages ...
[06:48:57.354] - Argument 'globals':
[06:48:57.354] logi TRUE
[06:48:57.354] - attr(*, "add")= chr "...future.x_ii"
[06:48:57.354] - attr(*, "ignore")= chr "ii"
[06:48:57.359] - R expression (map-reduce expression searched for globals):
[06:48:57.359] {
[06:48:57.359] NULL
[06:48:57.359] "# doFuture():::doFuture2(): process chunk of elements"
[06:48:57.359] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:48:57.359] ...future.x_jj <- ...future.x_ii[[jj]]
[06:48:57.359] {
[06:48:57.359] NULL
[06:48:57.359] ii <- NULL
[06:48:57.359] }
[06:48:57.359] ...future.env <- environment()
[06:48:57.359] local({
[06:48:57.359] for (name in names(...future.x_jj)) {
[06:48:57.359] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:48:57.359] inherits = FALSE)
[06:48:57.359] }
[06:48:57.359] })
[06:48:57.359] NULL
[06:48:57.359] tryCatch(ii, error = identity)
[06:48:57.359] })
[06:48:57.359] }
[06:48:57.383] - R expression (%dofuture% expression searched for globals):
[06:48:57.383] ii
[06:48:57.386] - Globals in %dofuture% R expression not in map-reduce expression:
[06:48:57.387] - Appending 0 globals only found in the vanilla %dofuture% expression:
[06:48:57.387] - globals: [1] '...future.x_ii'
[06:48:57.387] List of 1
[06:48:57.387] $ ...future.x_ii: num 42
[06:48:57.387] - attr(*, "where")=List of 1
[06:48:57.387] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:48:57.387] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:48:57.387] - attr(*, "resolved")= logi FALSE
[06:48:57.387] - attr(*, "total_size")= num 39
[06:48:57.394] - packages: [1] 'doFuture'
[06:48:57.394] - identifying globals and packages ... DONE
[06:48:57.394] Launching 1 futures (chunks) ...
[06:48:57.395] Chunk #1 of 1 ...
[06:48:57.396] - Finding globals in 'args_list' for chunk #1 ...
[06:48:57.397]
[06:48:57.398]
[06:48:57.398] - Finding globals in 'args_list' for chunk #1 ... DONE
[06:48:57.398] - seeds: <none>
[06:48:57.409] Chunk #1 of 1 ... DONE
[06:48:57.410] Launching 1 futures (chunks) ... DONE
[06:48:57.410] - resolving futures
[06:48:57.410] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture2-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: c879d416420255c1f5fe179bbe41b2e4-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture2-1'
Expression:
{
NULL
"# doFuture():::doFuture2(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
NULL
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: c879d416420255c1f5fe179bbe41b2e4
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Running the tests in 'tests/foreach_dopar,cluster-missing-doFuture-pkg.R' failed.
Complete output:
> source("incl/start.R")
Loading required package: foreach
Loading required package: future
R version 4.4.3 (2025-02-28 ucrt)
Platform: x86_64-w64-mingw32/x64
Running under: Windows Server 2022 x64 (build 20348)
Matrix products: default
locale:
[1] LC_COLLATE=C LC_CTYPE=German_Germany.utf8
[3] LC_MONETARY=C LC_NUMERIC=C
[5] LC_TIME=C
time zone: Europe/Berlin
tzcode source: internal
attached base packages:
[1] stats graphics grDevices utils datasets methods base
other attached packages:
[1] doFuture_1.0.2 future_1.40.0 foreach_1.5.2
loaded via a namespace (and not attached):
[1] compiler_4.4.3 parallelly_1.43.0 tools_4.4.3
[4] parallel_4.4.3 future.apply_1.11.3 listenv_0.9.1
[7] codetools_0.2-20 iterators_1.0.14 digest_0.6.37
[10] globals_0.17.0
> options(future.debug = FALSE)
>
> message("*** cluster() ...")
*** cluster() ...
>
> registerDoFuture()
>
> message("Library paths: ", paste(sQuote(.libPaths()), collapse = ", "))
Library paths: 'D:/temp/2025_04_19_01_50_00_15476/RtmpsVaBxi/RLIBS_206cc7ab72aa9', 'D:/RCompile/recent/R-4.4.3/library'
> message("Package path: ", sQuote(system.file(package = "future")))
Package path: 'D:/RCompile/CRANpkg/lib/4.4/future'
>
> types <- "PSOCK"
> #if (supportsMulticore()) types <- c(types, "FORK")
>
> setupClusterWithoutPkgs <- function(type = "PSOCK",
+ withs = c("digest", "globals",
+ "listenv", "future"),
+ withouts = c("doFuture")) {
+ cl <- parallel::makeCluster(1L, type = type, timeout = 60)
+
+ ## Emulate a worker that does not have 'future' installed.
+ ## by setting a different user library path on the worker.
+ libs <- parallel::clusterEvalQ(cl, .libPaths(tempdir()))[[1]]
+ attr(cl, "libs") <- libs
+
+ ## 'withouts' tops 'withs' for conveniency
+ withs <- setdiff(withs, withouts)
+
+ ## "Install" any 'withs' packages?
+ if (length(withs) > 0L) {
+ paths <- find.package(withs)
+ res <- parallel::clusterCall(cl, fun = sapply, X = paths,
+ FUN = file.copy, to = libs[1],
+ recursive = TRUE)[[1]]
+ res <- parallel::clusterCall(cl, fun = sapply, X = withs,
+ FUN = requireNamespace)[[1]]
+ }
+ attr(cl, "withs") <- res
+
+ ## Check whether 'future' is still available on the worker or not.
+ ## It could be that it is installed in the system library path, which
+ ## in case we cannot "hide" the future package from the worker.
+ res <- parallel::clusterCall(cl, fun = sapply, X = withouts,
+ FUN = requireNamespace)[[1]]
+ attr(cl, "withouts") <- res
+
+ cl
+ }
>
>
> cl <- NULL
> for (type in types) {
+ message(sprintf("Test set #1 with cluster type %s ...", sQuote(type)))
+
+ cl <- setupClusterWithoutPkgs(type, withouts = c("future", "doFuture"))
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## Package 'future' is not installed on worker (r_version: ...)>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ cl <- setupClusterWithoutPkgs(type)
+ if (all(attr(cl, "withs")) && !all(attr(cl, "withouts"))) {
+ plan(cluster, workers = cl, .init = FALSE)
+
+ ## Here we will get:
+ ## <UnexpectedFutureResultError: Unexpected result (of class
+ ## 'snow-try-error' != 'FutureResult') retrieved for ClusterFuture
+ ## future (label = '<none>', expression = '{ ... }'):
+ ## there is no package called 'doFuture'>
+ ## Note: This error is produced by the future backend when it recieves
+ ## the unexpected results.
+ res <- tryCatch({
+ y <- foreach(ii = 1:3) %dopar% ii
+ }, error = identity)
+ print(res)
+ stopifnot(inherits(res, "FutureError"))
+ }
+ parallel::stopCluster(cl)
+ cl <- NULL
+
+ plan(sequential)
+
+ message(sprintf("Test set #1 with cluster type %s ... DONE", sQuote(type)))
+ } ## for (type ...)
Test set #1 with cluster type 'PSOCK' ...
[06:51:13.484] doFuture() ...
[06:51:13.488] - dummy globals (as locals): [1] 'ii'
[06:51:13.489] - R expression:
[06:51:13.489] {
[06:51:13.489] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:51:13.489] "# also in nested calls "
[06:51:13.489] doFuture::registerDoFuture()
[06:51:13.489] "# doFuture():::doFuture(): process chunk of elements"
[06:51:13.489] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:51:13.489] ...future.x_jj <- ...future.x_ii[[jj]]
[06:51:13.489] {
[06:51:13.489] NULL
[06:51:13.489] ii <- NULL
[06:51:13.489] }
[06:51:13.489] ...future.env <- environment()
[06:51:13.489] local({
[06:51:13.489] for (name in names(...future.x_jj)) {
[06:51:13.489] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:51:13.489] inherits = FALSE)
[06:51:13.489] }
[06:51:13.489] })
[06:51:13.489] tryCatch(ii, error = identity)
[06:51:13.489] })
[06:51:13.489] }
[06:51:13.491] - identifying globals and packages ...
[06:51:13.520] List of 1
[06:51:13.520] $ ...future.x_ii: NULL
[06:51:13.520] - attr(*, "where")=List of 1
[06:51:13.520] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:51:13.520] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:51:13.520] - attr(*, "resolved")= logi FALSE
[06:51:13.520] - attr(*, "total_size")= num 27
[06:51:13.533] - R expression:
[06:51:13.534] {
[06:51:13.534] "# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
[06:51:13.534] "# also in nested calls "
[06:51:13.534] doFuture::registerDoFuture()
[06:51:13.534] "# doFuture():::doFuture(): process chunk of elements"
[06:51:13.534] lapply(seq_along(...future.x_ii), FUN = function(jj) {
[06:51:13.534] ...future.x_jj <- ...future.x_ii[[jj]]
[06:51:13.534] {
[06:51:13.534] NULL
[06:51:13.534] ii <- NULL
[06:51:13.534] }
[06:51:13.534] ...future.env <- environment()
[06:51:13.534] local({
[06:51:13.534] for (name in names(...future.x_jj)) {
[06:51:13.534] assign(name, ...future.x_jj[[name]], envir = ...future.env,
[06:51:13.534] inherits = FALSE)
[06:51:13.534] }
[06:51:13.534] })
[06:51:13.534] tryCatch(ii, error = identity)
[06:51:13.534] })
[06:51:13.534] }
[06:51:13.535] - globals: [1] '...future.x_ii'
[06:51:13.536] List of 1
[06:51:13.536] $ ...future.x_ii: NULL
[06:51:13.536] - attr(*, "where")=List of 1
[06:51:13.536] ..$ ...future.x_ii:<environment: R_EmptyEnv>
[06:51:13.536] - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[06:51:13.536] - attr(*, "resolved")= logi FALSE
[06:51:13.536] - attr(*, "total_size")= num 27
[06:51:13.543] - packages: [1] 'doFuture'
[06:51:13.543] - identifying globals and packages ... DONE
[06:51:13.635] Number of chunks: 1
[06:51:13.636] Number of futures (= number of chunks): 1
[06:51:13.636] Launching 1 futures (chunks) ...
[06:51:13.636] Chunk #1 of 1 ...
[06:51:13.637] - Finding globals in 'args_list' chunk #1 ...
[06:51:13.639]
[06:51:13.639]
[06:51:13.640] - Finding globals in 'args_list' for chunk #1 ... DONE
[06:51:13.650] Chunk #1 of 1 ... DONE
[06:51:13.651] Launching 1 futures (chunks) ... DONE
[06:51:13.651] - resolving futures
[06:51:13.651] - gathering results & relaying conditions (except errors)
<FutureInterruptError: A future ('doFuture-1') of class ClusterFuture was interrupted, while running on 'localhost'>
Future UUID: 2cdb72b955b75197715bc9e519a8f3c2-2
DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
ClusterFuture:
Label: 'doFuture-1'
Expression:
{
"# doFuture():::doFuture(): Make sure that foreach uses 'doFuture'"
"# also in nested calls "
doFuture::registerDoFuture()
"# doFuture():::doFuture(): process chunk of elements"
lapply(seq_along(...future.x_ii), FUN = function(jj) {
...future.x_jj <- ...future.x_ii[[jj]]
{
NULL
ii <- NULL
}
...future.env <- environment()
local({
for (name in names(...future.x_jj)) {
assign(name, ...future.x_jj[[name]], envir = ...future.env,
inherits = FALSE)
}
})
tryCatch(ii, error = identity)
})
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding '<none>')
Immediate condition classes: 'immediateCondition'
Globals: 1 objects totaling 194 bytes (list '...future.x_ii' of 194 bytes)
Packages: 1 packages ('doFuture')
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 2cdb72b955b75197715bc9e519a8f3c2
Class: 'ClusterFuture', 'MultiprocessFuture', 'Future'
DEBUG: END TROUBLESHOOTING HELP
Error in serialize(data, node$con) : error writing to connection
Calls: <Anonymous> ... postNode -> sendData -> sendData.SOCKnode -> serialize
Execution halted
Flavor: r-oldrel-windows-x86_64