Last updated on 2023-02-09 06:55:31 CET.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 0.5.0 | 8.04 | 153.47 | 161.51 | OK | |
| r-devel-linux-x86_64-debian-gcc | 0.5.0 | 6.81 | 114.23 | 121.04 | OK | |
| r-devel-linux-x86_64-fedora-clang | 0.5.0 | 204.46 | OK | |||
| r-devel-linux-x86_64-fedora-gcc | 0.5.0 | 210.78 | OK | |||
| r-devel-windows-x86_64 | 0.5.0 | 41.00 | 239.00 | 280.00 | ERROR | |
| r-patched-linux-x86_64 | 0.5.0 | 8.34 | 147.94 | 156.28 | OK | |
| r-release-linux-x86_64 | 0.5.0 | 5.67 | 141.32 | 146.99 | OK | |
| r-release-macos-arm64 | 0.5.0 | 77.00 | OK | |||
| r-release-macos-x86_64 | 0.5.0 | 106.00 | OK | |||
| r-release-windows-x86_64 | 0.5.0 | 47.00 | 241.00 | 288.00 | OK | |
| r-oldrel-macos-arm64 | 0.5.0 | 84.00 | OK | |||
| r-oldrel-macos-x86_64 | 0.5.0 | 111.00 | OK | |||
| r-oldrel-windows-ix86+x86_64 | 0.5.0 | 19.00 | 223.00 | 242.00 | ERROR |
Version: 0.5.0
Check: tests
Result: ERROR
Running 'Test-class.R' [46s]
Running 'check.R' [17s]
Running 'cli_fcn.R' [3s]
Running 'db_state.R' [5s]
Running 'evaluate_expr.R' [3s]
Running 'one-test.R' [6s]
Running 'progress.R' [3s]
Running 'test_db.R' [6s]
Running 'test_plans.R' [5s]
Running 'utils.R' [3s]
Running 'zzz.onLoad.R' [8s]
Running the tests in 'tests/check.R' failed.
Complete output:
> check <- future.tests::check
>
> message("*** check() ...")
*** check() ...
>
> ## Validate options
> check()
Usage: Rscript -e future.tests::check --args <options>
Options:
--help Display this help
--test-timeout=<seconds> Sets per-test timeout in seconds
--test-tags=<tags> Comma-separated tags specifying tests to include
--test-plan=<plan> Future plan to test against
--session-info Output session information at the end
Example:
Rscript -e future.tests::check --args --help
Rscript -e future.tests::check --args --test-plan=sequential
Rscript -e future.tests::check --args --test-plan=multisession,workers=4
> check(.args = c("--debug", "--help"))
Usage: Rscript -e future.tests::check --args <options>
Options:
--help Display this help
--test-timeout=<seconds> Sets per-test timeout in seconds
--test-tags=<tags> Comma-separated tags specifying tests to include
--test-plan=<plan> Future plan to test against
--session-info Output session information at the end
Example:
Rscript -e future.tests::check --args --help
Rscript -e future.tests::check --args --test-plan=sequential
Rscript -e future.tests::check --args --test-plan=multisession,workers=4
>
> ## Run checks with plan(sequential)
> results <- check(plan = "sequential", session_info = TRUE, debug = TRUE)
── Settings ────────────────────────────────────────────────────────────────────
- future.tests version : 0.5.0
- R_FUTURE_TESTS_ROOT :
- Option 'future.tests.root': NULL
- Default test set folder : D:/RCompile/CRANpkg/lib/4.3/future.tests/test-db
- Max number of workers : 2
- Timeout : N/A
── Running 51 test sets with plan(sequential) ──────────────────────────────────
ℹ Backend package: future 1.31.0
- future() - conditions
\ future() - conditions (1/1)
✔ future() - conditions (1 test) (154ms)
- %<-% - conditions
\ %<-% - conditions (1/1)
✔ %<-% - conditions (1 test) (174ms)
- future() - muffle conditions
\ future() - muffle conditions (1/1)
✔ future() - muffle conditions (1 test) (80ms)
- Argument '...'
\ Argument '...' (1/1)
✔ Argument '...' (1 test) (19ms)
- Argument '...' from parent function
\ Argument '...' from parent function (1/1)
✔ Argument '...' from parent function (1 test) (15ms)
- Argument '...' - non existing
\ Argument '...' - non existing (1/1)
✔ Argument '...' - non existing (1 test) (15ms)
- Argument '...' - exception
\ Argument '...' - exception (1/1)
✔ Argument '...' - exception (1 test) (18ms)
- Early signaling of errors
\ Early signaling of errors (1/4)
| Early signaling of errors (2/4)
/ Early signaling of errors (3/4)
- Early signaling of errors (4/4)
✔ Early signaling of errors (4 tests) (41ms)
- Early signaling of warnings
\ Early signaling of warnings (1/4)
| Early signaling of warnings (2/4)
/ Early signaling of warnings (3/4)
- Early signaling of warnings (4/4)
✔ Early signaling of warnings (4 tests) (44ms)
- Early signaling of messages
\ Early signaling of messages (1/4)
| Early signaling of messages (2/4)
/ Early signaling of messages (3/4)
- Early signaling of messages (4/4)
✔ Early signaling of messages (4 tests) (52ms)
- futureAssign() - lazy evaluation
\ futureAssign() - lazy evaluation (1/2)
| futureAssign() - lazy evaluation (2/2)
✔ futureAssign() - lazy evaluation (2 tests) (22ms)
- futureAssign() - potential task name clashes
\ futureAssign() - potential task name clashes (1/1)
✔ futureAssign() - potential task name clashes (1 test) (21ms)
- futureAssign() - global variables with and without lazy evaluation
\ futureAssign() - global variables with and without lazy evaluation (1/2)
| futureAssign() - global variables with and without lazy evaluation (2/2)
✔ futureAssign() - global variables with and without lazy evaluation (2 tests) (54ms)
- futureAssign() - lazy evaluation via disposable option
\ futureAssign() - lazy evaluation via disposable option (1/2)
| futureAssign() - lazy evaluation via disposable option (2/2)
✔ futureAssign() - lazy evaluation via disposable option (2 tests) (27ms)
- %<-% - local evaluation
\ %<-% - local evaluation (1/2)
| %<-% - local evaluation (2/2)
✔ %<-% - local evaluation (2 tests) (32ms)
- %<-% - local evaluation & global variable
\ %<-% - local evaluation & global variable (1/2)
| %<-% - local evaluation & global variable (2/2)
✔ %<-% - local evaluation & global variable (2 tests) (27ms)
- %<-% - errors
\ %<-% - errors (1/2)
| %<-% - errors (2/2)
✔ %<-% - errors (2 tests) (30ms)
- %<-% - errors and listenv
\ %<-% - errors and listenv (1/2)
| %<-% - errors and listenv (2/2)
✔ %<-% - errors and listenv (2 tests) (101ms)
- %<-% & %->%
\ %<-% & %->% (1/2)
| %<-% & %->% (2/2)
✖ %<-% & %->% (2 tests) (24ms)
✔ lazy=FALSE
✖ lazy=TRUE
- %<-% - nested
\ %<-% - nested (1/1)
✔ %<-% - nested (1 test) (58ms)
- futureCall()
\ futureCall() (1/4)
| futureCall() (2/4)
/ futureCall() (3/4)
- futureCall() (4/4)
✔ futureCall() (4 tests) (148ms)
- futureCall() - globals = list(a = 3)
\ futureCall() - globals = list(a = 3) (1/2)
| futureCall() - globals = list(a = 3) (2/2)
✔ futureCall() - globals = list(a = 3) (2 tests) (30ms)
- futureCall() - globals = "a"
\ futureCall() - globals = "a" (1/2)
| futureCall() - globals = "a" (2/2)
✔ futureCall() - globals = "a" (2 tests) (20ms)
- future() - rm() a global variable
\ future() - rm() a global variable (1/2)
| future() - rm() a global variable (2/2)
✔ future() - rm() a global variable (2 tests) (28ms)
- future() - non-exported package objects
\ future() - non-exported package objects (1/1)
✔ future() - non-exported package objects (1 test) (100ms)
- future() - NSE '...'
\ future() - NSE '...' (1/1)
✔ future() - NSE '...' (1 test) (19ms)
- resolved() on lazy futures
\ resolved() on lazy futures (1/1)
✔ resolved() on lazy futures (1 test) (9ms)
- demo("mandelbrot", package = "future")
\ demo("mandelbrot", package = "future") (1/2)
| demo("mandelbrot", package = "future") (2/2)
✔ demo("mandelbrot", package = "future") (2 tests) (829ms)
- nbrOfWorkers()
\ nbrOfWorkers() (1/1)
✔ nbrOfWorkers() (1 test) (2ms)
- future() - preserve R options
\ future() - preserve R options (1/1)
✔ future() - preserve R options (1 test) (211ms)
- future() - preserve R options
\ future() - preserve R options (1/1)
✔ future() - preserve R options (1 test) (143ms)
- plan()
\ plan() (1/1)
✔ plan() (1 test) (2ms)
- plan() - workers=<numeric>
\ plan() - workers=<numeric> (1/1)
✔ plan() - workers=<numeric> (1 test) (1ms)
- plan() - workers=<function>
\ plan() - workers=<function> (1/1)
✔ plan() - workers=<function> (1 test) (2ms)
- plan() - workers=<invalid>
\ plan() - workers=<invalid> (1/1)
✔ plan() - workers=<invalid> (1 test) (1ms)
- resolve()
\ resolve() (1/8)
| resolve() (2/8)
/ resolve() (3/8)
- resolve() (4/8)
\ resolve() (5/8)
| resolve() (6/8)
/ resolve() (7/8)
- resolve() (8/8)
✔ resolve() (8 tests) (4.2s)
- resolve() - run-time exception
\ resolve() - run-time exception (1/8)
| resolve() - run-time exception (2/8)
/ resolve() - run-time exception (3/8)
- resolve() - run-time exception (4/8)
\ resolve() - run-time exception (5/8)
| resolve() - run-time exception (6/8)
/ resolve() - run-time exception (7/8)
- resolve() - run-time exception (8/8)
✔ resolve() - run-time exception (8 tests) (93ms)
- resolve(<list of futures and values>)
\ resolve(<list of futures and values>) (1/2)
| resolve(<list of futures and values>) (2/2)
✔ resolve(<list of futures and values>) (2 tests) (29ms)
- resolve(<list of futures>)
\ resolve(<list of futures>) (1/2)
| resolve(<list of futures>) (2/2)
✔ resolve(<list of futures>) (2 tests) (39ms)
- resolve(<named matrix list of futures and values>) - time ordering
\ resolve(<named matrix list of futures and values>) - time ordering (1/1)
✔ resolve(<named matrix list of futures and values>) - time ordering (1 test) (529ms)
- resolved() - assert non-blocking while launching lazy futures
\ resolved() - assert non-blocking while launching lazy futures (1/1)
✔ resolved() - assert non-blocking while launching lazy futures (1 test) (3.1s)
- Random Number Generation (RNG) - seeds and preserving RNGkind
\ Random Number Generation (RNG) - seeds and preserving RNGkind (1/1)
✔ Random Number Generation (RNG) - seeds and preserving RNGkind (1 test) (11ms)
- Random Number Generation (RNG) - future
\ Random Number Generation (RNG) - future (1/2)
| Random Number Generation (RNG) - future (2/2)
✔ Random Number Generation (RNG) - future (2 tests) (259ms)
- Random Number Generation (RNG) - %<-%
\ Random Number Generation (RNG) - %<-% (1/2)
| Random Number Generation (RNG) - %<-% (2/2)
✔ Random Number Generation (RNG) - %<-% (2 tests) (199ms)
- Orchestration Stability - future() does not update RNG state
\ Orchestration Stability - future() does not update RNG state (1/1)
✔ Orchestration Stability - future() does not update RNG state (1 test) (16ms)
- Orchestration Stability - run() does not update RNG state
\ Orchestration Stability - run() does not update RNG state (1/1)
✔ Orchestration Stability - run() does not update RNG state (1 test) (14ms)
- Orchestration Stability - result() does not update RNG state
\ Orchestration Stability - result() does not update RNG state (1/1)
✔ Orchestration Stability - result() does not update RNG state (1 test) (21ms)
- Orchestration Stability - value() does not update RNG state
\ Orchestration Stability - value() does not update RNG state (1/1)
✔ Orchestration Stability - value() does not update RNG state (1 test) (17ms)
- future() - standard output
\ future() - standard output (1/2)
| future() - standard output (2/2)
✔ future() - standard output (2 tests) (80ms)
- %<-% - standard output
\ %<-% - standard output (1/2)
| %<-% - standard output (2/2)
✔ %<-% - standard output (2 tests) (55ms)
- value() - visibility
\ value() - visibility (1/1)
✔ value() - visibility (1 test) (20ms)
Number of tests: 95
Duration: 12.9s
Results: 1 error ✖ | 0 timeouts ✔
─ Session info ───────────────────────────────────────────────────────────────
setting value
version R Under development (unstable) (2023-02-07 r83776 ucrt)
os Windows Server 2022 x64 (build 20348)
system x86_64, mingw32
ui RTerm
language C
collate C
ctype German_Germany.utf8
tz Europe/Berlin
date 2023-02-08
pandoc 2.14.0.1 @ C:\\PROGRA~1\\Pandoc\\pandoc.exe
─ Packages ───────────────────────────────────────────────────────────────────
! package * version date (UTC) lib source
P bit * 4.0.5 2022-11-15 [?] CRAN (R 4.3.0)
P cli 3.6.0 2023-01-09 [?] CRAN (R 4.3.0)
P codetools 0.2-19 2023-02-01 [?] CRAN (R 4.3.0)
P crayon 1.5.2 2022-09-29 [?] CRAN (R 4.3.0)
P data.table 1.14.6 2022-11-16 [?] CRAN (R 4.3.0)
P digest 0.6.31 2022-12-11 [?] CRAN (R 4.3.0)
P ff * 4.0.9 2023-01-25 [?] CRAN (R 4.3.0)
P future * 1.31.0 2023-02-01 [?] CRAN (R 4.3.0)
P future.tests 0.5.0 2022-12-16 [?] CRAN (R 4.3.0)
P globals 0.16.2 2022-11-21 [?] CRAN (R 4.3.0)
P listenv 0.9.0 2022-12-16 [?] CRAN (R 4.3.0)
P parallelly 1.34.0 2023-01-13 [?] CRAN (R 4.3.0)
P prettyunits 1.1.1 2020-01-24 [?] CRAN (R 4.3.0)
P sessioninfo 1.2.2 2021-12-06 [?] CRAN (R 4.3.0)
[1] D:/temp/RtmpopHxdd/RLIBS_1d6cc38889c3
[2] D:/RCompile/recent/R/library
P ── Loaded and on-disk path mismatch.
──────────────────────────────────────────────────────────────────────────────
[[1]]
[[1]][[1]]
[[1]][[1]][[1]]
TestResult:
- Test:
- Title: 'future() - conditions'
- Tags: 'future', 'conditions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: truth <- captureConditions({
17: message("hello")
18: warning("whoops")
19: message("world")
20: })
21: f <- future({
22: print(1:3)
23: message("hello")
24: warning("whoops")
25: message("world")
26: 42L
27: })
28: r <- result(f)
29: str(r)
30: stopifnot(value(f) == 42L)
31: conditions <- r$conditions
32: stopifnot(is.list(conditions), length(conditions) == 3L)
33: conditions <- lapply(conditions, FUN = function(c) c$condition)
34: for (kk in seq_along(conditions)) {
35: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
36: identical(conditions[[kk]]$message, truth[[kk]]$message))
37: }
38: conditions <- captureConditions(value(f))
39: stopifnot(is.list(conditions), length(conditions) == 3L)
40: for (kk in seq_along(conditions)) {
41: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
42: identical(conditions[[kk]]$message, truth[[kk]]$message))
43: }
44: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'List of 9'
2: ' $ value : int 42'
3: ' $ visible : logi TRUE'
4: ' $ stdout : chr "[1] 1 2 3\n"'
5: ' $ conditions:List of 3'
6: ' ..$ :List of 2'
7: ' .. ..$ condition:List of 2'
8: ' .. .. ..$ message: chr "hello\n"'
9: ' .. .. ..$ call : language message("hello")'
10: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleMessage" "message" "condition"'
11: ' .. ..$ signaled : int 0'
12: ' ..$ :List of 2'
13: ' .. ..$ condition:List of 2'
14: ' .. .. ..$ message: chr "whoops"'
15: ' .. .. ..$ call : language eval(quote({ print(1:3) ...'
16: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleWarning" "warning" "condition"'
17: ' .. ..$ signaled : int 0'
18: ' ..$ :List of 2'
19: ' .. ..$ condition:List of 2'
20: ' .. .. ..$ message: chr "world\n"'
21: ' .. .. ..$ call : language message("world")'
22: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleMessage" "message" "condition"'
23: ' .. ..$ signaled : int 0'
24: ' $ rng : logi FALSE'
25: ' $ started : POSIXct[1:1], format: "2023-02-08 19:27:36"'
26: ' $ finished : POSIXct[1:1], format: "2023-02-08 19:27:36"'
27: ' $ r_info :List of 4'
28: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
29: ' .. ..$ : int [1:3] 4 3 0'
30: ' ..$ os : chr "windows"'
31: ' ..$ os_name : chr "Windows"'
32: ' ..$ captures_utf8: logi TRUE'
33: ' $ version : chr "1.8"'
34: ' - attr(*, "class")= chr "FutureResult"'
35: '[1] 1 2 3'
36: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.154 secs
[[1]][[2]]
[[1]][[2]][[1]]
TestResult:
- Test:
- Title: '%<-% - conditions'
- Tags: '%<-%', 'conditions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: truth <- captureConditions({
17: message("hello")
18: warning("whoops")
19: message("world")
20: })
21: v %<-% {
22: print(1:3)
23: message("hello")
24: warning("whoops")
25: message("world")
26: 42L
27: }
28: conditions <- captureConditions(v)
29: stopifnot(v == 42L)
30: stopifnot(is.list(conditions), length(conditions) == 3L)
31: for (kk in seq_along(conditions)) {
32: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
33: identical(conditions[[kk]]$message, truth[[kk]]$message))
34: }
35: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.174 secs
[[1]][[3]]
[[1]][[3]][[1]]
TestResult:
- Test:
- Title: 'future() - muffle conditions'
- Tags: 'future', 'conditions', 'muffle'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: f <- future({
17: print(1:3)
18: message("hello")
19: warning("whoops")
20: message("world")
21: 42L
22: }, conditions = character(0L))
23: r <- result(f)
24: str(r)
25: stopifnot(value(f) == 42L)
26: conditions <- r$conditions
27: stopifnot(is.list(conditions), length(conditions) == 0L)
28: conditions <- captureConditions(value(f))
29: stopifnot(is.list(conditions), length(conditions) == 0L)
30: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'List of 9'
2: ' $ value : int 42'
3: ' $ visible : logi TRUE'
4: ' $ stdout : chr "[1] 1 2 3\n"'
5: ' $ conditions: list()'
6: ' $ rng : logi FALSE'
7: ' $ started : POSIXct[1:1], format: "2023-02-08 19:27:36"'
8: ' $ finished : POSIXct[1:1], format: "2023-02-08 19:27:36"'
9: ' $ r_info :List of 4'
10: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
11: ' .. ..$ : int [1:3] 4 3 0'
12: ' ..$ os : chr "windows"'
13: ' ..$ os_name : chr "Windows"'
14: ' ..$ captures_utf8: logi TRUE'
15: ' $ version : chr "1.8"'
16: ' - attr(*, "class")= chr "FutureResult"'
17: '[1] 1 2 3'
18: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.079 secs
[[1]][[4]]
[[1]][[4]][[1]]
TestResult:
- Test:
- Title: 'Argument '...''
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, ...) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, ...)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(y == 6)
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.018 secs
[[1]][[5]]
[[1]][[5]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' from parent function'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, ...) {
3: sumt <- function(x) {
4: message("Arguments '...' exists: ", exists("...",
5: inherits = TRUE))
6: y %<-% {
7: sum(x, ...)
8: }
9: y
10: }
11: sumt(x)
12: }
13: y <- try(fcn(1:2, 3))
14: print(y)
15: stopifnot(y == 6)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.015 secs
[[1]][[6]]
[[1]][[6]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' - non existing'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, y) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, y)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(y == 6)
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[7]]
[[1]][[7]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' - exception'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, y) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, y, ...)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(inherits(y, "try-error"))
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Error in eval(quote({ : '...' used in an incorrect context'
2: '[1] "Error in eval(quote({ : '...' used in an incorrect context\n"'
3: 'attr(,"class")'
4: '[1] "try-error"'
5: 'attr(,"condition")'
6: '<simpleError in eval(quote({ sum(x, y, ...)}), new.env()): '...' used in an incorrect context>'
- Success: TRUE
- Processing time: 0.018 secs
[[1]][[8]]
[[1]][[8]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[8]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[8]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[8]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[9]]
[[1]][[9]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[9]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[9]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[9]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[10]]
[[1]][[10]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[10]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.013 secs
[[1]][[10]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.018 secs
[[1]][[10]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[11]]
[[1]][[11]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: delayedAssign("a", {
3: cat("Delayed assignment evaluated\n")
4: 1
5: })
6: futureAssign("b", {
7: cat("Future assignment evaluated\n")
8: 2
9: }, lazy = lazy)
10: cat(sprintf("b = %s\n", b))
11: cat(sprintf("a = %s\n", a))
12: stopifnot(identical(a, 1))
13: stopifnot(identical(b, 2))
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future assignment evaluated'
2: 'b = 2'
3: 'Delayed assignment evaluated'
4: 'a = 1'
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[11]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: delayedAssign("a", {
3: cat("Delayed assignment evaluated\n")
4: 1
5: })
6: futureAssign("b", {
7: cat("Future assignment evaluated\n")
8: 2
9: }, lazy = lazy)
10: cat(sprintf("b = %s\n", b))
11: cat(sprintf("a = %s\n", a))
12: stopifnot(identical(a, 1))
13: stopifnot(identical(b, 2))
14: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future assignment evaluated'
2: 'b = 2'
3: 'Delayed assignment evaluated'
4: 'a = 1'
- Success: TRUE
- Processing time: 0.012 secs
[[1]][[12]]
[[1]][[12]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - potential task name clashes'
- Tags: 'futureAssign'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: u <- new.env()
3: v <- new.env()
4: futureAssign("a", {
5: 2
6: }, assign.env = u)
7: futureAssign("a", {
8: 4
9: }, assign.env = v)
10: cat(sprintf("u$a = %s\n", u$a))
11: cat(sprintf("v$a = %s\n", v$a))
12: stopifnot(identical(u$a, 2))
13: stopifnot(identical(v$a, 4))
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'u$a = 2'
2: 'v$a = 4'
- Success: TRUE
- Processing time: 0.021 secs
[[1]][[13]]
[[1]][[13]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - global variables with and without lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 1
3: futureAssign("b", {
4: 2 * a
5: })
6: a <- 2
7: stopifnot(b == 2)
8: a <- 1
9: f <- futureAssign("b", {
10: 2 + a
11: }, lazy = lazy)
12: a <- 2
13: stopifnot(b == 3)
14: print(f)
15: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '{'
5: ' 2 + a'
6: '}'
7: 'Lazy evaluation: FALSE'
8: 'Asynchronous evaluation: FALSE'
9: 'Local evaluation: TRUE'
10: 'Environment: 0x000002be9cc8b9b0'
11: 'Capture standard output: TRUE'
12: 'Capture condition classes: 'condition' (excluding 'nothing')'
13: 'Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)'
14: 'Packages: <none>'
15: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
16: 'Resolved: TRUE'
17: 'Value: 56 bytes of class 'numeric''
18: 'Early signaling: FALSE'
19: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
20: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.030 secs
[[1]][[13]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - global variables with and without lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 1
3: futureAssign("b", {
4: 2 * a
5: })
6: a <- 2
7: stopifnot(b == 2)
8: a <- 1
9: f <- futureAssign("b", {
10: 2 + a
11: }, lazy = lazy)
12: a <- 2
13: stopifnot(b == 3)
14: print(f)
15: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '{'
5: ' 2 + a'
6: '}'
7: 'Lazy evaluation: TRUE'
8: 'Asynchronous evaluation: FALSE'
9: 'Local evaluation: TRUE'
10: 'Environment: 0x000002be9d41c030'
11: 'Capture standard output: TRUE'
12: 'Capture condition classes: 'condition' (excluding 'nothing')'
13: 'Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)'
14: 'Packages: <none>'
15: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
16: 'Resolved: TRUE'
17: 'Value: 56 bytes of class 'numeric''
18: 'Early signaling: FALSE'
19: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
20: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.023 secs
[[1]][[14]]
[[1]][[14]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation via disposable option'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: options(future.disposable = list(lazy = lazy))
3: on.exit(options(future.disposable = NULL))
4: a <- 1
5: f <- futureAssign("b", {
6: 4/a
7: })
8: a <- 2
9: stopifnot(b == 4)
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[14]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation via disposable option'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: options(future.disposable = list(lazy = lazy))
3: on.exit(options(future.disposable = NULL))
4: a <- 1
5: f <- futureAssign("b", {
6: 4/a
7: })
8: a <- 2
9: stopifnot(b == 4)
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.013 secs
[[1]][[15]]
[[1]][[15]][[1]]
TestResult:
- Test:
- Title: '%<-% - local evaluation'
- Tags: '%<-%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 1
4: } %lazy% lazy
5: stopifnot(!exists("x", inherits = FALSE), identical(v, 1))
6: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.020 secs
[[1]][[15]][[2]]
TestResult:
- Test:
- Title: '%<-% - local evaluation'
- Tags: '%<-%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 1
4: } %lazy% lazy
5: stopifnot(!exists("x", inherits = FALSE), identical(v, 1))
6: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.012 secs
[[1]][[16]]
[[1]][[16]][[1]]
TestResult:
- Test:
- Title: '%<-% - local evaluation & global variable'
- Tags: '%<-%', 'lazy', 'global'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 2
3: v %<-% {
4: x <- a
5: } %lazy% lazy
6: stopifnot(!exists("x", inherits = FALSE), identical(v, a))
7: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[16]][[2]]
TestResult:
- Test:
- Title: '%<-% - local evaluation & global variable'
- Tags: '%<-%', 'lazy', 'global'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 2
3: v %<-% {
4: x <- a
5: } %lazy% lazy
6: stopifnot(!exists("x", inherits = FALSE), identical(v, a))
7: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.013 secs
[[1]][[17]]
[[1]][[17]][[1]]
TestResult:
- Test:
- Title: '%<-% - errors'
- Tags: '%<-%', 'lazy', 'error'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 3
4: stop("Woops!")
5: x
6: } %lazy% lazy
7: stopifnot(!exists("x", inherits = FALSE))
8: res <- tryCatch(identical(v, 3), error = identity)
9: stopifnot(inherits(res, "error"))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[17]][[2]]
TestResult:
- Test:
- Title: '%<-% - errors'
- Tags: '%<-%', 'lazy', 'error'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 3
4: stop("Woops!")
5: x
6: } %lazy% lazy
7: stopifnot(!exists("x", inherits = FALSE))
8: res <- tryCatch(identical(v, 3), error = identity)
9: stopifnot(inherits(res, "error"))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[18]]
[[1]][[18]][[1]]
TestResult:
- Test:
- Title: '%<-% - errors and listenv'
- Tags: '%<-%', 'lazy', 'error', 'listenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: y <- listenv::listenv()
3: for (ii in 1:3) {
4: y[[ii]] %<-% {
5: if (ii%%2 == 0)
6: stop("Woops!")
7: ii
8: }
9: } %lazy% lazy
10: res <- tryCatch(as.list(y), error = identity)
11: stopifnot(inherits(res, "error"))
12: z <- y[c(1, 3)]
13: z <- unlist(z)
14: stopifnot(all(z == c(1, 3)))
15: res <- tryCatch(y[[2]], error = identity)
16: stopifnot(inherits(res, "error"))
17: res <- tryCatch(y[1:2], error = identity)
18: stopifnot(inherits(res, "error"))
19: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.051 secs
[[1]][[18]][[2]]
TestResult:
- Test:
- Title: '%<-% - errors and listenv'
- Tags: '%<-%', 'lazy', 'error', 'listenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: y <- listenv::listenv()
3: for (ii in 1:3) {
4: y[[ii]] %<-% {
5: if (ii%%2 == 0)
6: stop("Woops!")
7: ii
8: }
9: } %lazy% lazy
10: res <- tryCatch(as.list(y), error = identity)
11: stopifnot(inherits(res, "error"))
12: z <- y[c(1, 3)]
13: z <- unlist(z)
14: stopifnot(all(z == c(1, 3)))
15: res <- tryCatch(y[[2]], error = identity)
16: stopifnot(inherits(res, "error"))
17: res <- tryCatch(y[1:2], error = identity)
18: stopifnot(inherits(res, "error"))
19: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.049 secs
[[1]][[19]]
[[1]][[19]][[1]]
TestResult:
- Test:
- Title: '%<-% & %->%'
- Tags: '%<-%', '%->%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: c %<-% 1 %lazy% lazy
3: cat(sprintf("c = %s\n", c))
4: 1 %->% d %lazy% lazy
5: cat(sprintf("d = %s\n", d))
6: stopifnot(d == c)
7: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'c = 1'
2: 'd = 1'
- Success: TRUE
- Processing time: 0.015 secs
[[1]][[19]][[2]]
TestResult:
- Test:
- Title: '%<-% & %->%'
- Tags: '%<-%', '%->%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: c %<-% 1 %lazy% lazy
3: cat(sprintf("c = %s\n", c))
4: 1 %->% d %lazy% lazy
5: cat(sprintf("d = %s\n", d))
6: stopifnot(d == c)
7: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Error: promise already under evaluation: recursive default argument reference or earlier problems?
- Captured output:
1: ''
- Success: FALSE
- Processing time: 0.008 secs
[[1]][[20]]
[[1]][[20]][[1]]
TestResult:
- Test:
- Title: '%<-% - nested'
- Tags: '%<-%', 'nested'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: a %<-% {
3: b <- 1
4: c %<-% 2
5: d <- 3
6: 4 %->% e
7: b + c + d + e
8: }
9: cat(sprintf("a = %s\n", a))
10: stopifnot(a == 10)
11: {
12: a + 1
13: } %->% b
14: cat(sprintf("b = %s\n", b))
15: stopifnot(b == a + 1)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'a = 10'
2: 'b = 11'
- Success: TRUE
- Processing time: 0.057 secs
[[1]][[21]]
[[1]][[21]][[1]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: FALSE
2. globals: FALSE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9d082990'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 2 objects totaling 1.26 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 0 bytes of class 'NULL''
16: 'Conditions captured: [n=1] 'simpleError''
17: 'Early signaling: FALSE'
18: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
19: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
20: 'List of 2'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' - attr(*, "where")=List of 2'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1288'
31: ' - attr(*, "already-done")= logi TRUE'
32: '- FUN(): --------------------'
33: 'FUN : function (x, y) '
34: 'f : Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000002be9d0d1968> '
35: 'globals : logi FALSE'
36: 'lazy : logi FALSE'
37: 'stdout : logi TRUE'
38: 'v0 : num 90'
39: '-----------------------------'
40: 'List of 4'
41: ' $ globals: logi FALSE'
42: ' $ lazy : logi FALSE'
43: ' $ v0 : num 90'
44: ' $ res :List of 2'
45: ' ..$ message: chr "object 'a' not found"'
46: ' ..$ call : language (function (x, y) a * (x - y))(x = 42, y = 12)'
47: ' ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"'
- Success: TRUE
- Processing time: 0.040 secs
[[1]][[21]][[2]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: TRUE
2. globals: FALSE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9d7b93b0'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 2 objects totaling 1.26 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
19: 'Class: 'Future', 'environment''
20: 'List of 2'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' - attr(*, "where")=List of 2'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1288'
31: ' - attr(*, "already-done")= logi TRUE'
32: '- FUN(): --------------------'
33: 'FUN : function (x, y) '
34: 'f : Classes 'Future', 'environment' <environment: 0x000002be9d812a18> '
35: 'globals : logi FALSE'
36: 'lazy : logi TRUE'
37: 'stdout : logi TRUE'
38: 'v0 : num 90'
39: '-----------------------------'
40: 'List of 4'
41: ' $ globals: logi FALSE'
42: ' $ lazy : logi TRUE'
43: ' $ v0 : num 90'
44: ' $ res :List of 2'
45: ' ..$ message: chr "object 'a' not found"'
46: ' ..$ call : language (function (x, y) a * (x - y))(x = 42, y = 12)'
47: ' ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"'
- Success: TRUE
- Processing time: 0.038 secs
[[1]][[21]][[3]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9decb3f8'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
19: 'List of 3'
20: ' $ FUN :function (x, y) '
21: ' $ args:List of 2'
22: ' ..$ x: num 42'
23: ' ..$ y: num 12'
24: ' $ a : num 3'
25: ' - attr(*, "where")=List of 3'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' ..$ a :<environment: R_EmptyEnv> '
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1344'
31: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
32: ' - attr(*, "already-done")= logi TRUE'
33: '- FUN(): --------------------'
34: 'a : num 3'
35: '-----------------------------'
36: 'List of 4'
37: ' $ globals: logi TRUE'
38: ' $ lazy : logi FALSE'
39: ' $ v0 : num 90'
40: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.038 secs
[[1]][[21]][[4]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9ba3af08'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
19: 'Class: 'Future', 'environment''
20: 'List of 3'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' $ a : num 3'
26: ' - attr(*, "where")=List of 3'
27: ' ..$ FUN :<environment: R_EmptyEnv> '
28: ' ..$ args:<environment: R_EmptyEnv> '
29: ' ..$ a :<environment: R_EmptyEnv> '
30: ' - attr(*, "resolved")= logi FALSE'
31: ' - attr(*, "total_size")= num 1344'
32: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
33: ' - attr(*, "already-done")= logi TRUE'
34: '- FUN(): --------------------'
35: 'a : num 3'
36: '-----------------------------'
37: 'List of 4'
38: ' $ globals: logi TRUE'
39: ' $ lazy : logi TRUE'
40: ' $ v0 : num 90'
41: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[22]]
[[1]][[22]][[1]]
TestResult:
- Test:
- Title: 'futureCall() - globals = list(a = 3)'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-value'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) a * (x - y), args = args,
6: globals = list(a = 3), lazy = lazy)
7: rm(list = "args")
8: print(f)
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
15: stopifnot(all.equal(v, v0))
16: }
17: else {
18: stopifnot(!globals)
19: }
20: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9c66f7d8'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
19: 'List of 4'
20: ' $ globals: logi TRUE'
21: ' $ lazy : logi FALSE'
22: ' $ v0 : num 90'
23: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.015 secs
[[1]][[22]][[2]]
TestResult:
- Test:
- Title: 'futureCall() - globals = list(a = 3)'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-value'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) a * (x - y), args = args,
6: globals = list(a = 3), lazy = lazy)
7: rm(list = "args")
8: print(f)
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
15: stopifnot(all.equal(v, v0))
16: }
17: else {
18: stopifnot(!globals)
19: }
20: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9ca8a330'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
19: 'Class: 'Future', 'environment''
20: 'List of 4'
21: ' $ globals: logi TRUE'
22: ' $ lazy : logi TRUE'
23: ' $ v0 : num 90'
24: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.015 secs
[[1]][[23]]
[[1]][[23]][[1]]
TestResult:
- Test:
- Title: 'futureCall() - globals = "a"'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-name'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) {
6: a * (x - y)
7: }, args = args, globals = "a", lazy = lazy)
8: rm(list = c("a", "args"))
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: stopifnot(all.equal(v, v0))
15: }
16: else {
17: }
18: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[23]][[2]]
TestResult:
- Test:
- Title: 'futureCall() - globals = "a"'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-name'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) {
6: a * (x - y)
7: }, args = args, globals = "a", lazy = lazy)
8: rm(list = c("a", "args"))
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: stopifnot(all.equal(v, v0))
15: }
16: else {
17: }
18: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[24]]
[[1]][[24]][[1]]
TestResult:
- Test:
- Title: 'future() - rm() a global variable'
- Tags: 'future', 'globalenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 42
3: f <- future({
4: a
5: a <- 3.14
6: rm(a)
7: a
8: }, lazy = lazy)
9: rm(list = "a")
10: stopifnot(value(f) == 42L)
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.013 secs
[[1]][[24]][[2]]
TestResult:
- Test:
- Title: 'future() - rm() a global variable'
- Tags: 'future', 'globalenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 42
3: f <- future({
4: a
5: a <- 3.14
6: rm(a)
7: a
8: }, lazy = lazy)
9: rm(list = "a")
10: stopifnot(value(f) == 42L)
11: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[25]]
[[1]][[25]][[1]]
TestResult:
- Test:
- Title: 'future() - non-exported package objects'
- Tags: 'future', 'globals'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: if (requireNamespace("utils") && require("utils")) {
3: env <- pos.to.env(match("package:utils", search()))
4: ns <- getNamespace("utils")
5: privates <- setdiff(names(ns), names(env))
6: non_exported <- NULL
7: for (name in privates) {
8: if (exists(name, envir = ns, mode = "function", inherits = FALSE)) {
9: non_exported <- get(name, envir = ns, mode = "function",
10: inherits = FALSE)
11: }
12: }
13: stopifnot(is.function(non_exported))
14: f <- future({
15: non_exported
16: }, lazy = TRUE)
17: stopifnot("non_exported" %in% names(f$globals), identical(f$globals[["non_exported"]],
18: non_exported))
19: v <- value(f)
20: stopifnot(identical(v, non_exported))
21: }
22: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.099 secs
[[1]][[26]]
[[1]][[26]][[1]]
TestResult:
- Test:
- Title: 'future() - NSE '...''
- Tags: 'future', 'globals', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: my_fcn <- function(...) {
3: globals <- globals::globalsByName("...", envir = environment())
4: f <- future({
5: fcn <- function() sum(...)
6: fcn()
7: }, envir = parent.frame(), globals = globals)
8: v <- value(f)
9: v
10: }
11: y <- my_fcn()
12: stopifnot(y == 0L)
13: y <- my_fcn(1:10)
14: stopifnot(identical(y, 55L))
15: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.019 secs
[[1]][[27]]
[[1]][[27]][[1]]
TestResult:
- Test:
- Title: 'resolved() on lazy futures'
- Tags: 'resolved', 'lazy'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f <- future(42, lazy = TRUE)
3: while (!resolved(f)) {
4: Sys.sleep(0.1)
5: }
6: v <- value(f)
7: stopifnot(identical(v, 42))
8: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.008 secs
[[1]][[28]]
[[1]][[28]][[1]]
TestResult:
- Test:
- Title: 'demo("mandelbrot", package = "future")'
- Tags: 'demo', 'mandelbrot'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: if (getRversion() <= "3.2.0") {
3: message("Test requires R (>= 3.2.0). Skipping")
4: return()
5: }
6: options(future.demo.mandelbrot.nrow = 2L)
7: options(future.demo.mandelbrot.resolution = 50L)
8: options(future.demo.mandelbrot.delay = FALSE)
9: on.exit(grDevices::graphics.off())
10: demo("mandelbrot", package = "future", ask = FALSE)
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(value = NULL, visible = FALSE)
- Visible: FALSE
- Captured output:
1: ''
2: ''
3: ' demo(mandelbrot)'
4: ' ---- ~~~~~~~~~~'
5: ''
6: '> library("future")'
7: ''
8: '> library("graphics")'
9: ''
10: '> plot_what_is_done <- function(counts) {'
11: '+ for (kk in seq_along(counts)) {'
12: '+ f <- counts[[kk]]'
13: '+ '
14: '+ ## Already plotted?'
15: '+ if (!inherits(f, "Future")) next'
16: '+ '
17: '+ ## Not resolved?'
18: '+ if (!resolved(f)) next'
19: '+ '
20: '+ message(sprintf("Plotting tile #%d of %d ...", kk, n))'
21: '+ counts[[kk]] <- value(f)'
22: '+ screen(kk)'
23: '+ plot(counts[[kk]])'
24: '+ }'
25: '+ '
26: '+ counts'
27: '+ }'
28: ''
29: '> ## Options'
30: '> region <- getOption("future.demo.mandelbrot.region", 1L)'
31: ''
32: '> if (!is.list(region)) {'
33: '+ if (region == 1L) {'
34: '+ region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)'
35: '+ } else if (region == 2L) {'
36: '+ region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)'
37: '+ } else if (region == 3L) {'
38: '+ region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)'
39: '+ }'
40: '+ }'
41: ''
42: '> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)'
43: ''
44: '> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)'
45: ''
46: '> delay <- getOption("future.demo.mandelbrot.delay", interactive())'
47: ''
48: '> if (isTRUE(delay)) {'
49: '+ delay <- function(counts) Sys.sleep(1.0)'
50: '+ } else if (!is.function(delay)) {'
51: '+ delay <- function(counts) {}'
52: '+ }'
53: ''
54: '> ## Generate Mandelbrot tiles to be computed'
55: '> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,'
56: '+ side = region$side, nrow = nrow,'
57: '+ resolution = resolution)'
58: ''
59: '> if (interactive()) {'
60: '+ dev.new()'
61: '+ plot.new()'
62: '+ split.screen(dim(Cs))'
63: '+ for (ii in seq_along(Cs)) {'
64: '+ screen(ii)'
65: '+ par(mar = c(0, 0, 0, 0))'
66: '+ text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)'
67: '+ }'
68: '+ } else {'
69: '+ split.screen(dim(Cs))'
70: '+ }'
71: '[1] 1 2 3 4'
72: ''
73: '> ## Create all Mandelbrot tiles via lazy futures'
74: '> n <- length(Cs)'
75: ''
76: '> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)'
77: ''
78: '> counts <- lapply(seq_along(Cs), FUN=function(ii) {'
79: '+ message(" ", ii, appendLF = FALSE)'
80: '+ C <- Cs[[ii]]'
81: '+ future({'
82: '+ message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)'
83: '+ fit <- mandelbrot(C)'
84: '+ '
85: '+ ## Emulate slowness'
86: '+ delay(fit)'
87: '+ '
88: '+ message(" done")'
89: '+ fit'
90: '+ }, lazy = TRUE)'
91: '+ })'
92: ''
93: '> message(".")'
94: ''
95: '> ## Calculate and plot tiles'
96: '> repeat {'
97: '+ counts <- plot_what_is_done(counts)'
98: '+ if (!any(sapply(counts, FUN = inherits, "Future"))) break'
99: '+ }'
100: ''
101: '> close.screen()'
102: '[1] 1 2 3 4'
103: ''
104: '> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")'
- Success: TRUE
- Processing time: 0.445 secs
[[1]][[28]][[2]]
TestResult:
- Test:
- Title: 'demo("mandelbrot", package = "future")'
- Tags: 'demo', 'mandelbrot'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: if (getRversion() <= "3.2.0") {
3: message("Test requires R (>= 3.2.0). Skipping")
4: return()
5: }
6: options(future.demo.mandelbrot.nrow = 2L)
7: options(future.demo.mandelbrot.resolution = 50L)
8: options(future.demo.mandelbrot.delay = FALSE)
9: on.exit(grDevices::graphics.off())
10: demo("mandelbrot", package = "future", ask = FALSE)
11: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(value = NULL, visible = FALSE)
- Visible: FALSE
- Captured output:
1: ''
2: ''
3: ' demo(mandelbrot)'
4: ' ---- ~~~~~~~~~~'
5: ''
6: '> library("future")'
7: ''
8: '> library("graphics")'
9: ''
10: '> plot_what_is_done <- function(counts) {'
11: '+ for (kk in seq_along(counts)) {'
12: '+ f <- counts[[kk]]'
13: '+ '
14: '+ ## Already plotted?'
15: '+ if (!inherits(f, "Future")) next'
16: '+ '
17: '+ ## Not resolved?'
18: '+ if (!resolved(f)) next'
19: '+ '
20: '+ message(sprintf("Plotting tile #%d of %d ...", kk, n))'
21: '+ counts[[kk]] <- value(f)'
22: '+ screen(kk)'
23: '+ plot(counts[[kk]])'
24: '+ }'
25: '+ '
26: '+ counts'
27: '+ }'
28: ''
29: '> ## Options'
30: '> region <- getOption("future.demo.mandelbrot.region", 1L)'
31: ''
32: '> if (!is.list(region)) {'
33: '+ if (region == 1L) {'
34: '+ region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)'
35: '+ } else if (region == 2L) {'
36: '+ region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)'
37: '+ } else if (region == 3L) {'
38: '+ region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)'
39: '+ }'
40: '+ }'
41: ''
42: '> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)'
43: ''
44: '> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)'
45: ''
46: '> delay <- getOption("future.demo.mandelbrot.delay", interactive())'
47: ''
48: '> if (isTRUE(delay)) {'
49: '+ delay <- function(counts) Sys.sleep(1.0)'
50: '+ } else if (!is.function(delay)) {'
51: '+ delay <- function(counts) {}'
52: '+ }'
53: ''
54: '> ## Generate Mandelbrot tiles to be computed'
55: '> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,'
56: '+ side = region$side, nrow = nrow,'
57: '+ resolution = resolution)'
58: ''
59: '> if (interactive()) {'
60: '+ dev.new()'
61: '+ plot.new()'
62: '+ split.screen(dim(Cs))'
63: '+ for (ii in seq_along(Cs)) {'
64: '+ screen(ii)'
65: '+ par(mar = c(0, 0, 0, 0))'
66: '+ text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)'
67: '+ }'
68: '+ } else {'
69: '+ split.screen(dim(Cs))'
70: '+ }'
71: '[1] 1 2 3 4'
72: ''
73: '> ## Create all Mandelbrot tiles via lazy futures'
74: '> n <- length(Cs)'
75: ''
76: '> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)'
77: ''
78: '> counts <- lapply(seq_along(Cs), FUN=function(ii) {'
79: '+ message(" ", ii, appendLF = FALSE)'
80: '+ C <- Cs[[ii]]'
81: '+ future({'
82: '+ message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)'
83: '+ fit <- mandelbrot(C)'
84: '+ '
85: '+ ## Emulate slowness'
86: '+ delay(fit)'
87: '+ '
88: '+ message(" done")'
89: '+ fit'
90: '+ }, lazy = TRUE)'
91: '+ })'
92: ''
93: '> message(".")'
94: ''
95: '> ## Calculate and plot tiles'
96: '> repeat {'
97: '+ counts <- plot_what_is_done(counts)'
98: '+ if (!any(sapply(counts, FUN = inherits, "Future"))) break'
99: '+ }'
100: ''
101: '> close.screen()'
102: '[1] 1 2 3 4'
103: ''
104: '> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")'
- Success: TRUE
- Processing time: 0.384 secs
[[1]][[29]]
[[1]][[29]][[1]]
TestResult:
- Test:
- Title: 'nbrOfWorkers()'
- Tags: 'nbrOfWorkers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: n <- nbrOfWorkers()
3: message(sprintf("nbrOfWorkers: %g", n))
4: stopifnot(is.numeric(n), length(n) == 1L, n >= 1L)
5: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.001 secs
[[1]][[30]]
[[1]][[30]][[1]]
TestResult:
- Test:
- Title: 'future() - preserve R options'
- Tags: 'future', 'options', 'reset', 'data.table'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: if (requireNamespace("data.table")) {
3: data.table <- data.table::data.table
4: for (kk in 1:2) {
5: f <- future(data.table())
6: v <- value(f)
7: print(v)
8: stopifnot(inherits(v, "data.frame"), inherits(v,
9: "data.table"), nrow(v) == 0L, ncol(v) == 0L)
10: }
11: }
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Null data.table (0 rows and 0 cols)'
2: 'Null data.table (0 rows and 0 cols)'
- Success: TRUE
- Processing time: 0.210 secs
[[1]][[31]]
[[1]][[31]][[1]]
TestResult:
- Test:
- Title: 'future() - preserve R options'
- Tags: 'future', 'options', 'reset', 'ff'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: info <- Sys.info()
3: is_localhost <- value(future(identical(Sys.info(), info)))
4: if (is_localhost && requireNamespace("ff")) {
5: data <- ff::ff(1:12)
6: for (kk in 1:2) {
7: f <- future(data[4], packages = "ff")
8: v <- value(f)
9: print(v)
10: stopifnot(is.integer(v), length(v) == 1L, identical(v,
11: 4L))
12: }
13: }
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 4'
2: '[1] 4'
- Success: TRUE
- Processing time: 0.143 secs
[[1]][[32]]
[[1]][[32]][[1]]
TestResult:
- Test:
- Title: 'plan()'
- Tags: 'plan'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: print(current_plan)
4: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: structure(function (..., envir = parent.frame()) , {, future <- SequentialFuture(..., envir = envir), if (!future$lazy) , future <- run(future), invisible(future), }, class = c("FutureStrategy", "sequential", "uniprocess", "future", , "function"), call = plan(sequential))
- Visible: FALSE
- Captured output:
1: 'sequential:'
2: '- args: function (..., envir = parent.frame())'
3: '- tweaked: FALSE'
4: '- call: plan(sequential)'
- Success: TRUE
- Processing time: 0.002 secs
[[1]][[33]]
[[1]][[33]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<numeric>'
- Tags: 'plan', 'workers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: if (!inherits(current_plan, "multiprocess"))
4: return()
5: plan(current_plan, workers = 1L)
6: n <- nbrOfWorkers()
7: cat(sprintf("Number of workers: %d\n", n))
8: stopifnot(n == 1L)
9: f <- future(42L)
10: stopifnot(value(f) == 42L)
11: plan(current_plan, workers = 2L)
12: n <- nbrOfWorkers()
13: cat(sprintf("Number of workers: %d\n", n))
14: stopifnot(n == 2L)
15: f <- future(42L)
16: stopifnot(value(f) == 42L)
17: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.001 secs
[[1]][[34]]
[[1]][[34]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<function>'
- Tags: 'plan', 'workers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: n0 <- nbrOfWorkers()
4: if (!inherits(current_plan, "multiprocess"))
5: return()
6: workers_value <- eval(formals(current_plan)$workers)
7: workers <- function() workers_value
8: plan(current_plan, workers = workers)
9: n <- nbrOfWorkers()
10: cat(sprintf("Number of workers: %d\n", n))
11: stopifnot(n == n0)
12: f <- future(42L)
13: stopifnot(value(f) == 42L)
14: workers <- function() 1L
15: plan(current_plan, workers = workers)
16: n <- nbrOfWorkers()
17: cat(sprintf("Number of workers: %d\n", n))
18: stopifnot(n == 1L)
19: f <- future(42L)
20: stopifnot(value(f) == 42L)
21: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.001 secs
[[1]][[35]]
[[1]][[35]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<invalid>'
- Tags: 'plan', 'workers', 'exceptions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: if (!inherits(current_plan, "multiprocess"))
4: return()
5: res <- tryCatch({
6: plan(current_plan, workers = 0L)
7: }, error = identity)
8: print(res)
9: stopifnot(inherits(res, "error"))
10: res <- tryCatch({
11: plan(current_plan, workers = NA_integer_)
12: }, error = identity)
13: print(res)
14: stopifnot(inherits(res, "error"))
15: res <- tryCatch({
16: plan(current_plan, workers = TRUE)
17: }, error = identity)
18: print(res)
19: stopifnot(inherits(res, "error"))
20: res <- tryCatch({
21: plan(current_plan, workers = NA_character_)
22: }, error = identity)
23: print(res)
24: stopifnot(inherits(res, "error"))
25: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.001 secs
[[1]][[36]]
[[1]][[36]][[1]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.523 secs
[[1]][[36]][[2]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.517 secs
[[1]][[36]][[3]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.529 secs
[[1]][[36]][[4]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.528 secs
[[1]][[36]][[5]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.519 secs
[[1]][[36]][[6]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.526 secs
[[1]][[36]][[7]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.516 secs
[[1]][[36]][[8]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.514 secs
[[1]][[37]]
[[1]][[37]][[1]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[37]][[2]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.012 secs
[[1]][[37]][[3]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.012 secs
[[1]][[37]][[4]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[37]][[5]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[37]][[6]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[37]][[7]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.012 secs
[[1]][[37]][[8]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.010 secs
[[1]][[38]]
[[1]][[38]][[1]]
TestResult:
- Test:
- Title: 'resolve(<list of futures and values>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.015 secs
[[1]][[38]][[2]]
TestResult:
- Test:
- Title: 'resolve(<list of futures and values>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[39]]
[[1]][[39]][[1]]
TestResult:
- Test:
- Title: 'resolve(<list of futures>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = !lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.021 secs
[[1]][[39]][[2]]
TestResult:
- Test:
- Title: 'resolve(<list of futures>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = !lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.017 secs
[[1]][[40]]
[[1]][[40]][[1]]
TestResult:
- Test:
- Title: 'resolve(<named matrix list of futures and values>) - time ordering'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: x <- list()
3: x$a <- future(1)
4: x$b <- future({
5: Sys.sleep(0.5)
6: 2
7: })
8: x[[4]] <- 4
9: dim(x) <- c(2, 2)
10: y <- resolve(x, idxs = 1)
11: stopifnot(identical(y, x))
12: stopifnot(resolved(x[[1]]))
13: y <- resolve(x, idxs = 2)
14: stopifnot(identical(y, x))
15: stopifnot(resolved(x[[2]]))
16: y <- resolve(x, idxs = 3)
17: stopifnot(identical(y, x))
18: y <- resolve(x, idxs = seq_along(x))
19: stopifnot(identical(y, x))
20: y <- resolve(x, idxs = names(x))
21: stopifnot(identical(y, x))
22: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.529 secs
[[1]][[41]]
[[1]][[41]][[1]]
TestResult:
- Test:
- Title: 'resolved() - assert non-blocking while launching lazy futures'
- Tags: 'resolved', 'lazy'
- Reset workers: TRUE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: message("Creating lazy futures:")
3: n <- min(3, nbrOfWorkers() + 1L)
4: xs <- as.list(1:n)
5: fs <- lapply(xs, FUN = function(kk) {
6: future({
7: Sys.sleep(kk)
8: kk
9: }, lazy = TRUE)
10: })
11: vs <- vector("list", length = length(fs))
12: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
13: print(ss)
14: stopifnot(all(ss == "created"))
15: rs <- rep(NA, times = length(fs))
16: for (ff in seq_along(fs)) {
17: for (kk in ff:length(fs)) {
18: message(sprintf("Checking if future #%d is resolved:",
19: kk))
20: rs[[kk]] <- resolved(fs[[kk]])
21: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
22: print(ss)
23: nbrOfFinished <- sum(ss == "finished")
24: if (inherits(fs[[kk]], "UniprocessFuture")) {
25: stopifnot(rs[[kk]])
26: stopifnot(ss[[kk]] == "finished")
27: }
28: else if (inherits(fs[[kk]], "MultiprocessFuture")) {
29: if (nbrOfWorkers() + ff - 1L + nbrOfFinished >=
30: kk) {
31: stopifnot(ss[[kk]] == "running")
32: }
33: else {
34: stopifnot(ss[[kk]] == "created")
35: }
36: stopifnot(!rs[[kk]])
37: }
38: }
39: message(sprintf("Waiting for future #%d to finish ... ",
40: ff), appendLF = FALSE)
41: vs[[ff]] <- value(fs[[ff]])
42: message("done")
43: rs[[ff]] <- resolved(fs[[ff]])
44: stopifnot(rs[ff])
45: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
46: stopifnot(ss[ff] == "finished")
47: nbrOfFinished <- sum(ss == "finished")
48: if (inherits(fs[[kk]], "UniprocessFuture")) {
49: stopifnot(nbrOfFinished == length(fs))
50: }
51: else {
52: stopifnot(nbrOfFinished == ff)
53: }
54: }
55: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
56: print(ss)
57: stopifnot(all(ss == "finished"))
58: message("Collecting values:")
59: vs <- value(fs)
60: str(vs)
61: stopifnot(identical(vs, xs))
62: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] "created" "created"'
2: '[1] "finished" "created" '
3: '[1] "finished" "finished"'
4: '[1] "finished" "finished"'
5: '[1] "finished" "finished"'
6: 'List of 2'
7: ' $ : int 1'
8: ' $ : int 2'
- Success: TRUE
- Processing time: 3.103 secs
[[1]][[42]]
[[1]][[42]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - seeds and preserving RNGkind'
- Tags: 'rng', 'seed'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: okind <- RNGkind()
3: seed <- c(407L, 1420090545L, 65713854L, -990249945L, 1780737596L,
4: -1213437427L, 1082168682L)
5: f <- future(42, seed = seed)
6: print(f)
7: stopifnot(identical(f$seed, seed))
8: stopifnot(identical(RNGkind()[1], okind[1]))
9: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '[1] 42'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000002be9b8edb70'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: <none>'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: c(407, 1420090545, 65713854, -990249945, 1780737596, -1213437427, 1082168682)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: 5b75dc6b-d24b-7801-f907-34c299afc681'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.011 secs
[[1]][[43]]
[[1]][[43]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - future'
- Tags: 'rng', 'seed', 'lazy', 'future'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "future", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(3L, 1L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x000002be9b15c228>'
147: '<environment: 0x000002be9b148b30>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 3'
164: ''
165: '[[2]]'
166: '[1] 1'
167: ''
- Success: TRUE
- Processing time: 0.160 secs
[[1]][[43]][[2]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - future'
- Tags: 'rng', 'seed', 'lazy', 'future'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "future", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(1L, 2L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x000002be9b15c228>'
147: '<environment: 0x000002be9b148b30>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 1'
164: ''
165: '[[2]]'
166: '[1] 2'
167: ''
- Success: TRUE
- Processing time: 0.099 secs
[[1]][[44]]
[[1]][[44]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - %<-%'
- Tags: 'rng', 'seed', 'lazy', '%<-%'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "%<-%", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(0L, 1L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x000002be9b15c228>'
147: '<environment: 0x000002be9b148b30>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 0'
164: ''
165: '[[2]]'
166: '[1] 1'
167: ''
- Success: TRUE
- Processing time: 0.104 secs
[[1]][[44]][[2]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - %<-%'
- Tags: 'rng', 'seed', 'lazy', '%<-%'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "%<-%", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(3L, 3L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x000002be9b15c228>'
147: '<environment: 0x000002be9b148b30>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 3'
164: ''
165: '[[2]]'
166: '[1] 3'
167: ''
- Success: TRUE
- Processing time: 0.094 secs
[[1]][[45]]
[[1]][[45]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - future() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: rng0 <- globalenv()$.Random.seed
3: f1 <- future(1)
4: stopifnot(identical(globalenv()$.Random.seed, rng0))
5: f2 <- future(2)
6: stopifnot(identical(globalenv()$.Random.seed, rng0))
7: v1 <- value(f1)
8: stopifnot(identical(v1, 1))
9: v2 <- value(f2)
10: stopifnot(identical(v2, 2))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[46]]
[[1]][[46]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - run() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1, lazy = TRUE)
3: f2 <- future(2, lazy = TRUE)
4: rng0 <- globalenv()$.Random.seed
5: f1 <- run(f1)
6: stopifnot(identical(globalenv()$.Random.seed, rng0))
7: f2 <- run(f2)
8: stopifnot(identical(globalenv()$.Random.seed, rng0))
9: v1 <- value(f1)
10: stopifnot(identical(v1, 1))
11: v2 <- value(f2)
12: stopifnot(identical(v2, 2))
13: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.014 secs
[[1]][[47]]
[[1]][[47]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - result() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1)
3: f2 <- future(2)
4: rng0 <- globalenv()$.Random.seed
5: r1 <- result(f1)
6: stopifnot(identical(r1$value, 1))
7: stopifnot(identical(globalenv()$.Random.seed, rng0))
8: r2 <- result(f2)
9: stopifnot(identical(r2$value, 2))
10: stopifnot(identical(globalenv()$.Random.seed, rng0))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.020 secs
[[1]][[48]]
[[1]][[48]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - value() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1)
3: f2 <- future(2)
4: rng0 <- globalenv()$.Random.seed
5: v1 <- value(f1)
6: stopifnot(identical(v1, 1))
7: stopifnot(identical(globalenv()$.Random.seed, rng0))
8: v2 <- value(f2)
9: stopifnot(identical(v2, 2))
10: stopifnot(identical(globalenv()$.Random.seed, rng0))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[49]]
[[1]][[49]][[1]]
TestResult:
- Test:
- Title: 'future() - standard output'
- Tags: 'future', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: f <- future({
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: }, stdout = stdout)
19: r <- result(f)
20: str(r)
21: stopifnot(value(f) == 42L)
22: if (stdout) {
23: print(r)
24: message(sprintf("- stdout = %s", stdout))
25: stopifnot(identical(r$stdout, truth))
26: }
27: else {
28: print(r)
29: print(plan())
30: message(sprintf("- stdout = %s", stdout))
31: stopifnot(is.null(r$stdout) || r$stdout == "")
32: }
33: }
- Arguments tested:
1. stdout: FALSE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: 'List of 9'
3: ' $ value : int 42'
4: ' $ visible : logi TRUE'
5: ' $ stdout : NULL'
6: ' $ conditions: list()'
7: ' $ rng : logi FALSE'
8: ' $ started : POSIXct[1:1], format: "2023-02-08 19:27:48"'
9: ' $ finished : POSIXct[1:1], format: "2023-02-08 19:27:49"'
10: ' $ r_info :List of 4'
11: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
12: ' .. ..$ : int [1:3] 4 3 0'
13: ' ..$ os : chr "windows"'
14: ' ..$ os_name : chr "Windows"'
15: ' ..$ captures_utf8: logi TRUE'
16: ' $ version : chr "1.8"'
17: ' - attr(*, "class")= chr "FutureResult"'
18: 'FutureResult:'
19: 'value: 'integer''
20: 'visible: TRUE'
21: 'stdout: NULL'
22: 'conditions: [n = 0] '
23: 'RNG used: FALSE'
24: 'duration: 0.004915953 secs (started 2023-02-08 19:27:48.995927)'
25: 'version: 1.8'
26: 'sequential:'
27: '- args: function (..., envir = parent.frame())'
28: '- tweaked: FALSE'
29: '- call: plan(sequential)'
- Success: TRUE
- Processing time: 0.042 secs
[[1]][[49]][[2]]
TestResult:
- Test:
- Title: 'future() - standard output'
- Tags: 'future', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: f <- future({
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: }, stdout = stdout)
19: r <- result(f)
20: str(r)
21: stopifnot(value(f) == 42L)
22: if (stdout) {
23: print(r)
24: message(sprintf("- stdout = %s", stdout))
25: stopifnot(identical(r$stdout, truth))
26: }
27: else {
28: print(r)
29: print(plan())
30: message(sprintf("- stdout = %s", stdout))
31: stopifnot(is.null(r$stdout) || r$stdout == "")
32: }
33: }
- Arguments tested:
1. stdout: TRUE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: 'List of 9'
3: ' $ value : int 42'
4: ' $ visible : logi TRUE'
5: ' $ stdout : chr " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 3"| __truncated__'
6: ' $ conditions: list()'
7: ' $ rng : logi FALSE'
8: ' $ started : POSIXct[1:1], format: "2023-02-08 19:27:49"'
9: ' $ finished : POSIXct[1:1], format: "2023-02-08 19:27:49"'
10: ' $ r_info :List of 4'
11: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
12: ' .. ..$ : int [1:3] 4 3 0'
13: ' ..$ os : chr "windows"'
14: ' ..$ os_name : chr "Windows"'
15: ' ..$ captures_utf8: logi TRUE'
16: ' $ version : chr "1.8"'
17: ' - attr(*, "class")= chr "FutureResult"'
18: ' [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25'
19: '[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50'
20: ' int [1:50] 1 2 3 4 5 6 7 8 9 10 ...'
21: 'a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 '
22: '"Sepal.Length" "Sepal.Width" "Petal.Length" "Petal.Width" "Species"'
23: '"1" 5.1 3.5 1.4 0.2 "setosa"'
24: '"2" 4.9 3 1.4 0.2 "setosa"'
25: '"3" 4.7 3.2 1.3 0.2 "setosa"'
26: '"4" 4.6 3.1 1.5 0.2 "setosa"'
27: '"5" 5 3.6 1.4 0.2 "setosa"'
28: '"6" 5.4 3.9 1.7 0.4 "setosa"'
29: '"7" 4.6 3.4 1.4 0.3 "setosa"'
30: '"8" 5 3.4 1.5 0.2 "setosa"'
31: '"9" 4.4 2.9 1.4 0.2 "setosa"'
32: '"10" 4.9 3.1 1.5 0.1 "setosa"'
33: 'FutureResult:'
34: 'value: 'integer''
35: 'visible: TRUE'
36: 'stdout: character'
37: 'conditions: [n = 0] '
38: 'RNG used: FALSE'
39: 'duration: 0.004264116 secs (started 2023-02-08 19:27:49.050246)'
40: 'version: 1.8'
- Success: TRUE
- Processing time: 0.038 secs
[[1]][[50]]
[[1]][[50]][[1]]
TestResult:
- Test:
- Title: '%<-% - standard output'
- Tags: '%<-%', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: v %<-% {
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: } %stdout% stdout
19: out <- utils::capture.output(y <- v)
20: stopifnot(y == 42L)
21: if (!stdout) {
22: stopifnot(out == "")
23: }
24: else {
25: print(out)
26: stopifnot(identical(out, truth_rows))
27: }
28: }
- Arguments tested:
1. stdout: FALSE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[50]][[2]]
TestResult:
- Test:
- Title: '%<-% - standard output'
- Tags: '%<-%', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: v %<-% {
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: } %stdout% stdout
19: out <- utils::capture.output(y <- v)
20: stopifnot(y == 42L)
21: if (!stdout) {
22: stopifnot(out == "")
23: }
24: else {
25: print(out)
26: stopifnot(identical(out, truth_rows))
27: }
28: }
- Arguments tested:
1. stdout: TRUE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: ' [1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25" '
3: ' [2] "[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50" '
4: ' [3] " int [1:50] 1 2 3 4 5 6 7 8 9 10 ..." '
5: ' [4] "a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 " '
6: ' [5] "\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\""'
7: ' [6] "\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"" '
8: ' [7] "\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"" '
9: ' [8] "\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"" '
10: ' [9] "\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"" '
11: '[10] "\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"" '
12: '[11] "\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"" '
13: '[12] "\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"" '
14: '[13] "\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"" '
15: '[14] "\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"" '
16: '[15] "\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"" '
- Success: TRUE
- Processing time: 0.023 secs
[[1]][[51]]
[[1]][[51]][[1]]
TestResult:
- Test:
- Title: 'value() - visibility'
- Tags: 'value', 'visibility'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f <- future(42)
3: res <- withVisible({
4: value(f)
5: })
6: v <- res$value
7: stopifnot(identical(v, 42))
8: stopifnot(res$visible)
9: f <- future(invisible(42))
10: res <- withVisible({
11: value(f)
12: })
13: v <- res$value
14: stopifnot(identical(v, 42))
15: stopifnot(!res$visible)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.020 secs
attr(,"plan")
sequential:
- args: function (..., envir = parent.frame())
- tweaked: FALSE
- call: plan(sequential)
attr(,"exit_code")
[1] 1
Total number of errors: 1
> proc.time()
user system elapsed
8.50 0.26 16.90
Flavor: r-devel-windows-x86_64
Version: 0.5.0
Check: tests
Result: ERROR
Running 'Test-class.R' [45s]
Running 'check.R' [18s]
Running 'cli_fcn.R' [3s]
Running 'db_state.R' [5s]
Running 'evaluate_expr.R' [3s]
Running 'one-test.R' [5s]
Running 'progress.R' [3s]
Running 'test_db.R' [5s]
Running 'test_plans.R' [4s]
Running 'utils.R' [3s]
Running 'zzz.onLoad.R' [7s]
Running the tests in 'tests/check.R' failed.
Complete output:
> check <- future.tests::check
>
> message("*** check() ...")
*** check() ...
>
> ## Validate options
> check()
Usage: Rscript -e future.tests::check --args <options>
Options:
--help Display this help
--test-timeout=<seconds> Sets per-test timeout in seconds
--test-tags=<tags> Comma-separated tags specifying tests to include
--test-plan=<plan> Future plan to test against
--session-info Output session information at the end
Example:
Rscript -e future.tests::check --args --help
Rscript -e future.tests::check --args --test-plan=sequential
Rscript -e future.tests::check --args --test-plan=multisession,workers=4
> check(.args = c("--debug", "--help"))
Usage: Rscript -e future.tests::check --args <options>
Options:
--help Display this help
--test-timeout=<seconds> Sets per-test timeout in seconds
--test-tags=<tags> Comma-separated tags specifying tests to include
--test-plan=<plan> Future plan to test against
--session-info Output session information at the end
Example:
Rscript -e future.tests::check --args --help
Rscript -e future.tests::check --args --test-plan=sequential
Rscript -e future.tests::check --args --test-plan=multisession,workers=4
>
> ## Run checks with plan(sequential)
> results <- check(plan = "sequential", session_info = TRUE, debug = TRUE)
-- Settings --------------------------------------------------------------------
- future.tests version : 0.5.0
- R_FUTURE_TESTS_ROOT :
- Option 'future.tests.root': NULL
- Default test set folder : D:/temp/RtmpmSgb8t/RLIBS_16c64236d5cab/future.tests/test-db
- Max number of workers : 2
- Timeout : N/A
-- Running 51 test sets with plan(sequential) ----------------------------------
i Backend package: future 1.31.0
- future() - conditions
\ future() - conditions (1/1)
v future() - conditions (1 test) (125ms)
- %<-% - conditions
\ %<-% - conditions (1/1)
v %<-% - conditions (1 test) (63ms)
- future() - muffle conditions
\ future() - muffle conditions (1/1)
v future() - muffle conditions (1 test) (110ms)
- Argument '...'
\ Argument '...' (1/1)
v Argument '...' (1 test) (16ms)
- Argument '...' from parent function
\ Argument '...' from parent function (1/1)
v Argument '...' from parent function (1 test) (32ms)
- Argument '...' - non existing
\ Argument '...' - non existing (1/1)
v Argument '...' - non existing (1 test) (0ms)
- Argument '...' - exception
\ Argument '...' - exception (1/1)
v Argument '...' - exception (1 test) (16ms)
- Early signaling of errors
\ Early signaling of errors (1/4)
| Early signaling of errors (2/4)
/ Early signaling of errors (3/4)
- Early signaling of errors (4/4)
v Early signaling of errors (4 tests) (47ms)
- Early signaling of warnings
\ Early signaling of warnings (1/4)
| Early signaling of warnings (2/4)
/ Early signaling of warnings (3/4)
- Early signaling of warnings (4/4)
v Early signaling of warnings (4 tests) (47ms)
- Early signaling of messages
\ Early signaling of messages (1/4)
| Early signaling of messages (2/4)
/ Early signaling of messages (3/4)
- Early signaling of messages (4/4)
v Early signaling of messages (4 tests) (47ms)
- futureAssign() - lazy evaluation
\ futureAssign() - lazy evaluation (1/2)
| futureAssign() - lazy evaluation (2/2)
v futureAssign() - lazy evaluation (2 tests) (32ms)
- futureAssign() - potential task name clashes
\ futureAssign() - potential task name clashes (1/1)
v futureAssign() - potential task name clashes (1 test) (32ms)
- futureAssign() - global variables with and without lazy evaluation
\ futureAssign() - global variables with and without lazy evaluation (1/2)
| futureAssign() - global variables with and without lazy evaluation (2/2)
v futureAssign() - global variables with and without lazy evaluation (2 tests) (63ms)
- futureAssign() - lazy evaluation via disposable option
\ futureAssign() - lazy evaluation via disposable option (1/2)
| futureAssign() - lazy evaluation via disposable option (2/2)
v futureAssign() - lazy evaluation via disposable option (2 tests) (32ms)
- %<-% - local evaluation
\ %<-% - local evaluation (1/2)
| %<-% - local evaluation (2/2)
v %<-% - local evaluation (2 tests) (16ms)
- %<-% - local evaluation & global variable
\ %<-% - local evaluation & global variable (1/2)
| %<-% - local evaluation & global variable (2/2)
v %<-% - local evaluation & global variable (2 tests) (0ms)
- %<-% - errors
\ %<-% - errors (1/2)
| %<-% - errors (2/2)
v %<-% - errors (2 tests) (32ms)
- %<-% - errors and listenv
\ %<-% - errors and listenv (1/2)
| %<-% - errors and listenv (2/2)
v %<-% - errors and listenv (2 tests) (94ms)
- %<-% & %->%
\ %<-% & %->% (1/2)
| %<-% & %->% (2/2)
x %<-% & %->% (2 tests) (63ms)
v lazy=FALSE
x lazy=TRUE
- %<-% - nested
\ %<-% - nested (1/1)
v %<-% - nested (1 test) (47ms)
- futureCall()
\ futureCall() (1/4)
| futureCall() (2/4)
/ futureCall() (3/4)
- futureCall() (4/4)
v futureCall() (4 tests) (141ms)
- futureCall() - globals = list(a = 3)
\ futureCall() - globals = list(a = 3) (1/2)
| futureCall() - globals = list(a = 3) (2/2)
v futureCall() - globals = list(a = 3) (2 tests) (16ms)
- futureCall() - globals = "a"
\ futureCall() - globals = "a" (1/2)
| futureCall() - globals = "a" (2/2)
v futureCall() - globals = "a" (2 tests) (0ms)
- future() - rm() a global variable
\ future() - rm() a global variable (1/2)
| future() - rm() a global variable (2/2)
v future() - rm() a global variable (2 tests) (32ms)
- future() - non-exported package objects
\ future() - non-exported package objects (1/1)
v future() - non-exported package objects (1 test) (110ms)
- future() - NSE '...'
\ future() - NSE '...' (1/1)
v future() - NSE '...' (1 test) (16ms)
- resolved() on lazy futures
\ resolved() on lazy futures (1/1)
v resolved() on lazy futures (1 test) (16ms)
- demo("mandelbrot", package = "future")
\ demo("mandelbrot", package = "future") (1/2)
| demo("mandelbrot", package = "future") (2/2)
v demo("mandelbrot", package = "future") (2 tests) (1.5s)
- nbrOfWorkers()
\ nbrOfWorkers() (1/1)
v nbrOfWorkers() (1 test) (0ms)
- future() - preserve R options
\ future() - preserve R options (1/1)
v future() - preserve R options (1 test) (281ms)
- future() - preserve R options
\ future() - preserve R options (1/1)
v future() - preserve R options (1 test) (219ms)
- plan()
\ plan() (1/1)
v plan() (1 test) (0ms)
- plan() - workers=<numeric>
\ plan() - workers=<numeric> (1/1)
v plan() - workers=<numeric> (1 test) (0ms)
- plan() - workers=<function>
\ plan() - workers=<function> (1/1)
v plan() - workers=<function> (1 test) (0ms)
- plan() - workers=<invalid>
\ plan() - workers=<invalid> (1/1)
v plan() - workers=<invalid> (1 test) (0ms)
- resolve()
\ resolve() (1/8)
| resolve() (2/8)
/ resolve() (3/8)
- resolve() (4/8)
\ resolve() (5/8)
| resolve() (6/8)
/ resolve() (7/8)
- resolve() (8/8)
v resolve() (8 tests) (4.9s)
- resolve() - run-time exception
\ resolve() - run-time exception (1/8)
| resolve() - run-time exception (2/8)
/ resolve() - run-time exception (3/8)
- resolve() - run-time exception (4/8)
\ resolve() - run-time exception (5/8)
| resolve() - run-time exception (6/8)
/ resolve() - run-time exception (7/8)
- resolve() - run-time exception (8/8)
v resolve() - run-time exception (8 tests) (79ms)
- resolve(<list of futures and values>)
\ resolve(<list of futures and values>) (1/2)
| resolve(<list of futures and values>) (2/2)
v resolve(<list of futures and values>) (2 tests) (47ms)
- resolve(<list of futures>)
\ resolve(<list of futures>) (1/2)
| resolve(<list of futures>) (2/2)
v resolve(<list of futures>) (2 tests) (32ms)
- resolve(<named matrix list of futures and values>) - time ordering
\ resolve(<named matrix list of futures and values>) - time ordering (1/1)
v resolve(<named matrix list of futures and values>) - time ordering (1 test) (531ms)
- resolved() - assert non-blocking while launching lazy futures
\ resolved() - assert non-blocking while launching lazy futures (1/1)
v resolved() - assert non-blocking while launching lazy futures (1 test) (3.1s)
- Random Number Generation (RNG) - seeds and preserving RNGkind
\ Random Number Generation (RNG) - seeds and preserving RNGkind (1/1)
v Random Number Generation (RNG) - seeds and preserving RNGkind (1 test) (16ms)
- Random Number Generation (RNG) - future
\ Random Number Generation (RNG) - future (1/2)
| Random Number Generation (RNG) - future (2/2)
v Random Number Generation (RNG) - future (2 tests) (281ms)
- Random Number Generation (RNG) - %<-%
\ Random Number Generation (RNG) - %<-% (1/2)
| Random Number Generation (RNG) - %<-% (2/2)
v Random Number Generation (RNG) - %<-% (2 tests) (203ms)
- Orchestration Stability - future() does not update RNG state
\ Orchestration Stability - future() does not update RNG state (1/1)
v Orchestration Stability - future() does not update RNG state (1 test) (32ms)
- Orchestration Stability - run() does not update RNG state
\ Orchestration Stability - run() does not update RNG state (1/1)
v Orchestration Stability - run() does not update RNG state (1 test) (16ms)
- Orchestration Stability - result() does not update RNG state
\ Orchestration Stability - result() does not update RNG state (1/1)
v Orchestration Stability - result() does not update RNG state (1 test) (16ms)
- Orchestration Stability - value() does not update RNG state
\ Orchestration Stability - value() does not update RNG state (1/1)
v Orchestration Stability - value() does not update RNG state (1 test) (16ms)
- future() - standard output
\ future() - standard output (1/2)
| future() - standard output (2/2)
v future() - standard output (2 tests) (94ms)
- %<-% - standard output
\ %<-% - standard output (1/2)
| %<-% - standard output (2/2)
v %<-% - standard output (2 tests) (141ms)
- value() - visibility
\ value() - visibility (1/1)
v value() - visibility (1 test) (16ms)
Number of tests: 95
Duration: 14.7s
Results: 1 error x | 0 timeouts v
- Session info ---------------------------------------------------------------
setting value
version R version 4.1.3 (2022-03-10)
os Windows Server 2008 x64 (build 6003) SP 2
system x86_64, mingw32
ui RTerm
language C
collate C
ctype German_Germany.1252
tz Europe/Berlin
date 2023-02-07
pandoc 1.19.2.1 @ D:\\compiler\\pandoc\\pandoc.exe
- Packages -------------------------------------------------------------------
package * version date (UTC) lib source
bit * 4.0.5 2022-11-15 [1] CRAN (R 4.1.3)
cli 3.6.0 2023-01-09 [1] CRAN (R 4.1.3)
codetools 0.2-19 2023-02-01 [1] CRAN (R 4.1.3)
crayon 1.5.2 2022-09-29 [1] CRAN (R 4.1.3)
data.table 1.14.6 2022-11-16 [1] CRAN (R 4.1.3)
digest 0.6.31 2022-12-11 [1] CRAN (R 4.1.3)
ff * 4.0.9 2023-01-25 [1] CRAN (R 4.1.3)
future * 1.31.0 2023-02-01 [1] CRAN (R 4.1.3)
future.tests 0.5.0 2022-12-16 [1] CRAN (R 4.1.3)
globals 0.16.2 2022-11-21 [1] CRAN (R 4.1.3)
listenv 0.9.0 2022-12-16 [1] CRAN (R 4.1.3)
parallelly 1.34.0 2023-01-13 [1] CRAN (R 4.1.3)
prettyunits 1.1.1 2020-01-24 [1] CRAN (R 4.1.3)
sessioninfo 1.2.2 2021-12-06 [1] CRAN (R 4.1.3)
[1] D:/temp/RtmpmSgb8t/RLIBS_16c64236d5cab
[2] D:/RCompile/recent/R-4.1.3/library
------------------------------------------------------------------------------
[[1]]
[[1]][[1]]
[[1]][[1]][[1]]
TestResult:
- Test:
- Title: 'future() - conditions'
- Tags: 'future', 'conditions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: truth <- captureConditions({
17: message("hello")
18: warning("whoops")
19: message("world")
20: })
21: f <- future({
22: print(1:3)
23: message("hello")
24: warning("whoops")
25: message("world")
26: 42L
27: })
28: r <- result(f)
29: str(r)
30: stopifnot(value(f) == 42L)
31: conditions <- r$conditions
32: stopifnot(is.list(conditions), length(conditions) == 3L)
33: conditions <- lapply(conditions, FUN = function(c) c$condition)
34: for (kk in seq_along(conditions)) {
35: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
36: identical(conditions[[kk]]$message, truth[[kk]]$message))
37: }
38: conditions <- captureConditions(value(f))
39: stopifnot(is.list(conditions), length(conditions) == 3L)
40: for (kk in seq_along(conditions)) {
41: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
42: identical(conditions[[kk]]$message, truth[[kk]]$message))
43: }
44: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'List of 9'
2: ' $ value : int 42'
3: ' $ visible : logi TRUE'
4: ' $ stdout : chr "[1] 1 2 3\n"'
5: ' $ conditions:List of 3'
6: ' ..$ :List of 2'
7: ' .. ..$ condition:List of 2'
8: ' .. .. ..$ message: chr "hello\n"'
9: ' .. .. ..$ call : language message("hello")'
10: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleMessage" "message" "condition"'
11: ' .. ..$ signaled : int 0'
12: ' ..$ :List of 2'
13: ' .. ..$ condition:List of 2'
14: ' .. .. ..$ message: chr "whoops"'
15: ' .. .. ..$ call : language eval(quote({ print(1:3) ...'
16: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleWarning" "warning" "condition"'
17: ' .. ..$ signaled : int 0'
18: ' ..$ :List of 2'
19: ' .. ..$ condition:List of 2'
20: ' .. .. ..$ message: chr "world\n"'
21: ' .. .. ..$ call : language message("world")'
22: ' .. .. ..- attr(*, "class")= chr [1:3] "simpleMessage" "message" "condition"'
23: ' .. ..$ signaled : int 0'
24: ' $ rng : logi FALSE'
25: ' $ started : POSIXct[1:1], format: "2023-02-07 06:03:31"'
26: ' $ finished : POSIXct[1:1], format: "2023-02-07 06:03:31"'
27: ' $ r_info :List of 4'
28: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
29: ' .. ..$ : int [1:3] 4 1 3'
30: ' ..$ os : chr "windows"'
31: ' ..$ os_name : chr "Windows"'
32: ' ..$ captures_utf8: logi FALSE'
33: ' $ version : chr "1.8"'
34: ' - attr(*, "class")= chr "FutureResult"'
35: '[1] 1 2 3'
36: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.125 secs
[[1]][[2]]
[[1]][[2]][[1]]
TestResult:
- Test:
- Title: '%<-% - conditions'
- Tags: '%<-%', 'conditions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: truth <- captureConditions({
17: message("hello")
18: warning("whoops")
19: message("world")
20: })
21: v %<-% {
22: print(1:3)
23: message("hello")
24: warning("whoops")
25: message("world")
26: 42L
27: }
28: conditions <- captureConditions(v)
29: stopifnot(v == 42L)
30: stopifnot(is.list(conditions), length(conditions) == 3L)
31: for (kk in seq_along(conditions)) {
32: stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])),
33: identical(conditions[[kk]]$message, truth[[kk]]$message))
34: }
35: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.062 secs
[[1]][[3]]
[[1]][[3]][[1]]
TestResult:
- Test:
- Title: 'future() - muffle conditions'
- Tags: 'future', 'conditions', 'muffle'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: captureConditions <- function (...)
3: {
4: conditions <- list()
5: withCallingHandlers(..., condition = function(c) {
6: conditions[[length(conditions) + 1L]] <<- c
7: if (inherits(c, "message")) {
8: invokeRestart("muffleMessage")
9: }
10: else if (inherits(c, "warning")) {
11: invokeRestart("muffleWarning")
12: }
13: })
14: conditions
15: }
16: f <- future({
17: print(1:3)
18: message("hello")
19: warning("whoops")
20: message("world")
21: 42L
22: }, conditions = character(0L))
23: r <- result(f)
24: str(r)
25: stopifnot(value(f) == 42L)
26: conditions <- r$conditions
27: stopifnot(is.list(conditions), length(conditions) == 0L)
28: conditions <- captureConditions(value(f))
29: stopifnot(is.list(conditions), length(conditions) == 0L)
30: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'List of 9'
2: ' $ value : int 42'
3: ' $ visible : logi TRUE'
4: ' $ stdout : chr "[1] 1 2 3\n"'
5: ' $ conditions: list()'
6: ' $ rng : logi FALSE'
7: ' $ started : POSIXct[1:1], format: "2023-02-07 06:03:32"'
8: ' $ finished : POSIXct[1:1], format: "2023-02-07 06:03:32"'
9: ' $ r_info :List of 4'
10: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
11: ' .. ..$ : int [1:3] 4 1 3'
12: ' ..$ os : chr "windows"'
13: ' ..$ os_name : chr "Windows"'
14: ' ..$ captures_utf8: logi FALSE'
15: ' $ version : chr "1.8"'
16: ' - attr(*, "class")= chr "FutureResult"'
17: '[1] 1 2 3'
18: '[1] 1 2 3'
- Success: TRUE
- Processing time: 0.109 secs
[[1]][[4]]
[[1]][[4]][[1]]
TestResult:
- Test:
- Title: 'Argument '...''
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, ...) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, ...)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(y == 6)
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[5]]
[[1]][[5]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' from parent function'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, ...) {
3: sumt <- function(x) {
4: message("Arguments '...' exists: ", exists("...",
5: inherits = TRUE))
6: y %<-% {
7: sum(x, ...)
8: }
9: y
10: }
11: sumt(x)
12: }
13: y <- try(fcn(1:2, 3))
14: print(y)
15: stopifnot(y == 6)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[6]]
[[1]][[6]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' - non existing'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, y) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, y)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(y == 6)
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 6'
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[7]]
[[1]][[7]][[1]]
TestResult:
- Test:
- Title: 'Argument '...' - exception'
- Tags: '%<-%', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: fcn <- function(x, y) {
3: message("Arguments '...' exists: ", exists("...", inherits = TRUE))
4: y %<-% {
5: sum(x, y, ...)
6: }
7: y
8: }
9: y <- try(fcn(1:2, 3))
10: print(y)
11: stopifnot(inherits(y, "try-error"))
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Error in eval(quote({ : '...' used in an incorrect context'
2: '[1] "Error in eval(quote({ : '...' used in an incorrect context\n"'
3: 'attr(,"class")'
4: '[1] "try-error"'
5: 'attr(,"condition")'
6: '<simpleError in eval(quote({ sum(x, y, ...)}), new.env()): '...' used in an incorrect context>'
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[8]]
[[1]][[8]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[8]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[8]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[8]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of errors'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: stop("bang!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), error = identity)
9: stopifnot(inherits(v, "error"), conditionMessage(v) ==
10: "bang!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[9]]
[[1]][[9]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[9]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[9]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[9]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of warnings'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: warning("watch out!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), warning = identity)
9: stopifnot(inherits(v, "warning"), conditionMessage(v) ==
10: "watch out!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[10]]
[[1]][[10]][[1]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[10]][[2]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: FALSE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[10]][[3]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: FALSE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[10]][[4]]
TestResult:
- Test:
- Title: 'Early signaling of messages'
- Tags: 'earlySignal', 'resolved', 'resolve'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. earlySignal: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: res <- tryCatch({
3: f <- future({
4: message("hello world!")
5: }, lazy = lazy, earlySignal = earlySignal)
6: stopifnot(inherits(f, "Future"))
7: r <- resolved(f)
8: v <- tryCatch(value(f), message = identity)
9: stopifnot(inherits(v, "message"), conditionMessage(v) ==
10: "hello world!")
11: TRUE
12: }, error = identity)
13: stopifnot(inherits(res, "error") || isTRUE(res))
14: }
- Arguments tested:
1. lazy: TRUE
2. earlySignal: TRUE
3. globals: TRUE
4. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[11]]
[[1]][[11]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: delayedAssign("a", {
3: cat("Delayed assignment evaluated\n")
4: 1
5: })
6: futureAssign("b", {
7: cat("Future assignment evaluated\n")
8: 2
9: }, lazy = lazy)
10: cat(sprintf("b = %s\n", b))
11: cat(sprintf("a = %s\n", a))
12: stopifnot(identical(a, 1))
13: stopifnot(identical(b, 2))
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future assignment evaluated'
2: 'b = 2'
3: 'Delayed assignment evaluated'
4: 'a = 1'
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[11]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: delayedAssign("a", {
3: cat("Delayed assignment evaluated\n")
4: 1
5: })
6: futureAssign("b", {
7: cat("Future assignment evaluated\n")
8: 2
9: }, lazy = lazy)
10: cat(sprintf("b = %s\n", b))
11: cat(sprintf("a = %s\n", a))
12: stopifnot(identical(a, 1))
13: stopifnot(identical(b, 2))
14: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future assignment evaluated'
2: 'b = 2'
3: 'Delayed assignment evaluated'
4: 'a = 1'
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[12]]
[[1]][[12]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - potential task name clashes'
- Tags: 'futureAssign'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: u <- new.env()
3: v <- new.env()
4: futureAssign("a", {
5: 2
6: }, assign.env = u)
7: futureAssign("a", {
8: 4
9: }, assign.env = v)
10: cat(sprintf("u$a = %s\n", u$a))
11: cat(sprintf("v$a = %s\n", v$a))
12: stopifnot(identical(u$a, 2))
13: stopifnot(identical(v$a, 4))
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'u$a = 2'
2: 'v$a = 4'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[13]]
[[1]][[13]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - global variables with and without lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 1
3: futureAssign("b", {
4: 2 * a
5: })
6: a <- 2
7: stopifnot(b == 2)
8: a <- 1
9: f <- futureAssign("b", {
10: 2 + a
11: }, lazy = lazy)
12: a <- 2
13: stopifnot(b == 3)
14: print(f)
15: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '{'
5: ' 2 + a'
6: '}'
7: 'Lazy evaluation: FALSE'
8: 'Asynchronous evaluation: FALSE'
9: 'Local evaluation: TRUE'
10: 'Environment: 0x000000000d5f7d20'
11: 'Capture standard output: TRUE'
12: 'Capture condition classes: 'condition' (excluding 'nothing')'
13: 'Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)'
14: 'Packages: <none>'
15: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
16: 'Resolved: TRUE'
17: 'Value: 56 bytes of class 'numeric''
18: 'Early signaling: FALSE'
19: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
20: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[13]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - global variables with and without lazy evaluation'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 1
3: futureAssign("b", {
4: 2 * a
5: })
6: a <- 2
7: stopifnot(b == 2)
8: a <- 1
9: f <- futureAssign("b", {
10: 2 + a
11: }, lazy = lazy)
12: a <- 2
13: stopifnot(b == 3)
14: print(f)
15: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '{'
5: ' 2 + a'
6: '}'
7: 'Lazy evaluation: TRUE'
8: 'Asynchronous evaluation: FALSE'
9: 'Local evaluation: TRUE'
10: 'Environment: 0x0000000006f01428'
11: 'Capture standard output: TRUE'
12: 'Capture condition classes: 'condition' (excluding 'nothing')'
13: 'Globals: 1 objects totaling 56 bytes (numeric 'a' of 56 bytes)'
14: 'Packages: <none>'
15: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
16: 'Resolved: TRUE'
17: 'Value: 56 bytes of class 'numeric''
18: 'Early signaling: FALSE'
19: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
20: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[14]]
[[1]][[14]][[1]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation via disposable option'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: options(future.disposable = list(lazy = lazy))
3: on.exit(options(future.disposable = NULL))
4: a <- 1
5: f <- futureAssign("b", {
6: 4/a
7: })
8: a <- 2
9: stopifnot(b == 4)
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[14]][[2]]
TestResult:
- Test:
- Title: 'futureAssign() - lazy evaluation via disposable option'
- Tags: 'futureAssign', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: options(future.disposable = list(lazy = lazy))
3: on.exit(options(future.disposable = NULL))
4: a <- 1
5: f <- futureAssign("b", {
6: 4/a
7: })
8: a <- 2
9: stopifnot(b == 4)
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[15]]
[[1]][[15]][[1]]
TestResult:
- Test:
- Title: '%<-% - local evaluation'
- Tags: '%<-%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 1
4: } %lazy% lazy
5: stopifnot(!exists("x", inherits = FALSE), identical(v, 1))
6: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[15]][[2]]
TestResult:
- Test:
- Title: '%<-% - local evaluation'
- Tags: '%<-%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 1
4: } %lazy% lazy
5: stopifnot(!exists("x", inherits = FALSE), identical(v, 1))
6: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[16]]
[[1]][[16]][[1]]
TestResult:
- Test:
- Title: '%<-% - local evaluation & global variable'
- Tags: '%<-%', 'lazy', 'global'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 2
3: v %<-% {
4: x <- a
5: } %lazy% lazy
6: stopifnot(!exists("x", inherits = FALSE), identical(v, a))
7: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[16]][[2]]
TestResult:
- Test:
- Title: '%<-% - local evaluation & global variable'
- Tags: '%<-%', 'lazy', 'global'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 2
3: v %<-% {
4: x <- a
5: } %lazy% lazy
6: stopifnot(!exists("x", inherits = FALSE), identical(v, a))
7: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[17]]
[[1]][[17]][[1]]
TestResult:
- Test:
- Title: '%<-% - errors'
- Tags: '%<-%', 'lazy', 'error'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 3
4: stop("Woops!")
5: x
6: } %lazy% lazy
7: stopifnot(!exists("x", inherits = FALSE))
8: res <- tryCatch(identical(v, 3), error = identity)
9: stopifnot(inherits(res, "error"))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[17]][[2]]
TestResult:
- Test:
- Title: '%<-% - errors'
- Tags: '%<-%', 'lazy', 'error'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: v %<-% {
3: x <- 3
4: stop("Woops!")
5: x
6: } %lazy% lazy
7: stopifnot(!exists("x", inherits = FALSE))
8: res <- tryCatch(identical(v, 3), error = identity)
9: stopifnot(inherits(res, "error"))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[18]]
[[1]][[18]][[1]]
TestResult:
- Test:
- Title: '%<-% - errors and listenv'
- Tags: '%<-%', 'lazy', 'error', 'listenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: y <- listenv::listenv()
3: for (ii in 1:3) {
4: y[[ii]] %<-% {
5: if (ii%%2 == 0)
6: stop("Woops!")
7: ii
8: }
9: } %lazy% lazy
10: res <- tryCatch(as.list(y), error = identity)
11: stopifnot(inherits(res, "error"))
12: z <- y[c(1, 3)]
13: z <- unlist(z)
14: stopifnot(all(z == c(1, 3)))
15: res <- tryCatch(y[[2]], error = identity)
16: stopifnot(inherits(res, "error"))
17: res <- tryCatch(y[1:2], error = identity)
18: stopifnot(inherits(res, "error"))
19: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[18]][[2]]
TestResult:
- Test:
- Title: '%<-% - errors and listenv'
- Tags: '%<-%', 'lazy', 'error', 'listenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: y <- listenv::listenv()
3: for (ii in 1:3) {
4: y[[ii]] %<-% {
5: if (ii%%2 == 0)
6: stop("Woops!")
7: ii
8: }
9: } %lazy% lazy
10: res <- tryCatch(as.list(y), error = identity)
11: stopifnot(inherits(res, "error"))
12: z <- y[c(1, 3)]
13: z <- unlist(z)
14: stopifnot(all(z == c(1, 3)))
15: res <- tryCatch(y[[2]], error = identity)
16: stopifnot(inherits(res, "error"))
17: res <- tryCatch(y[1:2], error = identity)
18: stopifnot(inherits(res, "error"))
19: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[19]]
[[1]][[19]][[1]]
TestResult:
- Test:
- Title: '%<-% & %->%'
- Tags: '%<-%', '%->%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: c %<-% 1 %lazy% lazy
3: cat(sprintf("c = %s\n", c))
4: 1 %->% d %lazy% lazy
5: cat(sprintf("d = %s\n", d))
6: stopifnot(d == c)
7: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'c = 1'
2: 'd = 1'
- Success: TRUE
- Processing time: 0.062 secs
[[1]][[19]][[2]]
TestResult:
- Test:
- Title: '%<-% & %->%'
- Tags: '%<-%', '%->%', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: c %<-% 1 %lazy% lazy
3: cat(sprintf("c = %s\n", c))
4: 1 %->% d %lazy% lazy
5: cat(sprintf("d = %s\n", d))
6: stopifnot(d == c)
7: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Error: promise already under evaluation: recursive default argument reference or earlier problems?
- Captured output:
1: ''
- Success: FALSE
- Processing time: 0.000 secs
[[1]][[20]]
[[1]][[20]][[1]]
TestResult:
- Test:
- Title: '%<-% - nested'
- Tags: '%<-%', 'nested'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: a %<-% {
3: b <- 1
4: c %<-% 2
5: d <- 3
6: 4 %->% e
7: b + c + d + e
8: }
9: cat(sprintf("a = %s\n", a))
10: stopifnot(a == 10)
11: {
12: a + 1
13: } %->% b
14: cat(sprintf("b = %s\n", b))
15: stopifnot(b == a + 1)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'a = 10'
2: 'b = 11'
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[21]]
[[1]][[21]][[1]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: FALSE
2. globals: FALSE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000eb8f848'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 2 objects totaling 1.26 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 0 bytes of class 'NULL''
16: 'Conditions captured: [n=1] 'simpleError''
17: 'Early signaling: FALSE'
18: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
19: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
20: 'List of 2'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' - attr(*, "where")=List of 2'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1288'
31: ' - attr(*, "already-done")= logi TRUE'
32: '- FUN(): --------------------'
33: 'FUN : function (x, y) '
34: 'f : Classes 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment' <environment: 0x000000000ebd9188> '
35: 'globals : logi FALSE'
36: 'lazy : logi FALSE'
37: 'stdout : logi TRUE'
38: 'v0 : num 90'
39: '-----------------------------'
40: 'List of 4'
41: ' $ globals: logi FALSE'
42: ' $ lazy : logi FALSE'
43: ' $ v0 : num 90'
44: ' $ res :List of 2'
45: ' ..$ message: chr "object 'a' not found"'
46: ' ..$ call : language (function (x, y) a * (x - y))(x = 42, y = 12)'
47: ' ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[21]][[2]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: TRUE
2. globals: FALSE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000f2898d0'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 2 objects totaling 1.26 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
19: 'Class: 'Future', 'environment''
20: 'List of 2'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' - attr(*, "where")=List of 2'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1288'
31: ' - attr(*, "already-done")= logi TRUE'
32: '- FUN(): --------------------'
33: 'FUN : function (x, y) '
34: 'f : Classes 'Future', 'environment' <environment: 0x000000000f2cf040> '
35: 'globals : logi FALSE'
36: 'lazy : logi TRUE'
37: 'stdout : logi TRUE'
38: 'v0 : num 90'
39: '-----------------------------'
40: 'List of 4'
41: ' $ globals: logi FALSE'
42: ' $ lazy : logi TRUE'
43: ' $ v0 : num 90'
44: ' $ res :List of 2'
45: ' ..$ message: chr "object 'a' not found"'
46: ' ..$ call : language (function (x, y) a * (x - y))(x = 42, y = 12)'
47: ' ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"'
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[21]][[3]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000f9674e0'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
19: 'List of 3'
20: ' $ FUN :function (x, y) '
21: ' $ args:List of 2'
22: ' ..$ x: num 42'
23: ' ..$ y: num 12'
24: ' $ a : num 3'
25: ' - attr(*, "where")=List of 3'
26: ' ..$ FUN :<environment: R_EmptyEnv> '
27: ' ..$ args:<environment: R_EmptyEnv> '
28: ' ..$ a :<environment: R_EmptyEnv> '
29: ' - attr(*, "resolved")= logi FALSE'
30: ' - attr(*, "total_size")= num 1344'
31: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
32: ' - attr(*, "already-done")= logi TRUE'
33: '- FUN(): --------------------'
34: 'a : num 3'
35: '-----------------------------'
36: 'List of 4'
37: ' $ globals: logi TRUE'
38: ' $ lazy : logi FALSE'
39: ' $ v0 : num 90'
40: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[21]][[4]]
TestResult:
- Test:
- Title: 'futureCall()'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-automatic'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. globals: [n = 2] c(FALSE, TRUE)
=> Test combinations: 4 (= 2*2)
- Expression:
1: {
2: if (!isTRUE(getOption("future.tests.suppress_messages", TRUE))) {
3: options(future.debug = TRUE)
4: }
5: a <- 3
6: args <- list(x = 42, y = 12)
7: v0 <- do.call(function(x, y) a * (x - y), args = args)
8: f <- futureCall(function(x, y) a * (x - y), args = args,
9: globals = globals, lazy = lazy)
10: rm(list = c("a", "args"))
11: print(f)
12: str(f$globals)
13: cat("- FUN(): --------------------\n")
14: FUN <- f$globals$FUN
15: print(utils::ls.str(environment(FUN)))
16: cat("-----------------------------\n")
17: res <- tryCatch({
18: v <- value(f)
19: }, error = identity)
20: stopifnot(!inherits(res, "FutureError"))
21: if (!inherits(res, "error")) {
22: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
23: stopifnot(all.equal(v, v0))
24: }
25: else {
26: str(list(globals = globals, lazy = lazy, v0 = v0, res = res))
27: stopifnot(!globals)
28: }
29: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000dbb2af0'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (function 'FUN' of 1.15 KiB, list 'args' of 112 bytes, numeric 'a' of 56 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
19: 'Class: 'Future', 'environment''
20: 'List of 3'
21: ' $ FUN :function (x, y) '
22: ' $ args:List of 2'
23: ' ..$ x: num 42'
24: ' ..$ y: num 12'
25: ' $ a : num 3'
26: ' - attr(*, "where")=List of 3'
27: ' ..$ FUN :<environment: R_EmptyEnv> '
28: ' ..$ args:<environment: R_EmptyEnv> '
29: ' ..$ a :<environment: R_EmptyEnv> '
30: ' - attr(*, "resolved")= logi FALSE'
31: ' - attr(*, "total_size")= num 1344'
32: ' - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"'
33: ' - attr(*, "already-done")= logi TRUE'
34: '- FUN(): --------------------'
35: 'a : num 3'
36: '-----------------------------'
37: 'List of 4'
38: ' $ globals: logi TRUE'
39: ' $ lazy : logi TRUE'
40: ' $ v0 : num 90'
41: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[22]]
[[1]][[22]][[1]]
TestResult:
- Test:
- Title: 'futureCall() - globals = list(a = 3)'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-value'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) a * (x - y), args = args,
6: globals = list(a = 3), lazy = lazy)
7: rm(list = "args")
8: print(f)
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
15: stopifnot(all.equal(v, v0))
16: }
17: else {
18: stopifnot(!globals)
19: }
20: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000cfd1780'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
19: 'List of 4'
20: ' $ globals: logi TRUE'
21: ' $ lazy : logi FALSE'
22: ' $ v0 : num 90'
23: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[22]][[2]]
TestResult:
- Test:
- Title: 'futureCall() - globals = list(a = 3)'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-value'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) a * (x - y), args = args,
6: globals = list(a = 3), lazy = lazy)
7: rm(list = "args")
8: print(f)
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: str(list(globals = globals, lazy = lazy, v0 = v0, v = v))
15: stopifnot(all.equal(v, v0))
16: }
17: else {
18: stopifnot(!globals)
19: }
20: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Future:'
2: 'Label: '<none>''
3: 'Expression:'
4: 'do.call(what = FUN, args = args)'
5: 'Lazy evaluation: TRUE'
6: 'Asynchronous evaluation: TRUE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000e78ec00'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: 3 objects totaling 1.31 KiB (numeric 'a' of 56 bytes, function 'FUN' of 1.15 KiB, list 'args' of 112 bytes)'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)'
14: 'Resolved: FALSE'
15: 'Value: <not collected>'
16: 'Conditions captured: <none>'
17: 'Early signaling: FALSE'
18: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
19: 'Class: 'Future', 'environment''
20: 'List of 4'
21: ' $ globals: logi TRUE'
22: ' $ lazy : logi TRUE'
23: ' $ v0 : num 90'
24: ' $ v : num 90'
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[23]]
[[1]][[23]][[1]]
TestResult:
- Test:
- Title: 'futureCall() - globals = "a"'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-name'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) {
6: a * (x - y)
7: }, args = args, globals = "a", lazy = lazy)
8: rm(list = c("a", "args"))
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: stopifnot(all.equal(v, v0))
15: }
16: else {
17: }
18: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[23]][[2]]
TestResult:
- Test:
- Title: 'futureCall() - globals = "a"'
- Tags: 'futureCall', 'lazy', 'globals', 'globals-by-name'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 3
3: args <- list(x = 42, y = 12)
4: v0 <- do.call(function(x, y) a * (x - y), args = args)
5: f <- futureCall(function(x, y) {
6: a * (x - y)
7: }, args = args, globals = "a", lazy = lazy)
8: rm(list = c("a", "args"))
9: res <- tryCatch({
10: v <- value(f)
11: }, error = identity)
12: stopifnot(!inherits(res, "FutureError"))
13: if (!inherits(res, "error")) {
14: stopifnot(all.equal(v, v0))
15: }
16: else {
17: }
18: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[24]]
[[1]][[24]][[1]]
TestResult:
- Test:
- Title: 'future() - rm() a global variable'
- Tags: 'future', 'globalenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 42
3: f <- future({
4: a
5: a <- 3.14
6: rm(a)
7: a
8: }, lazy = lazy)
9: rm(list = "a")
10: stopifnot(value(f) == 42L)
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[24]][[2]]
TestResult:
- Test:
- Title: 'future() - rm() a global variable'
- Tags: 'future', 'globalenv'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: a <- 42
3: f <- future({
4: a
5: a <- 3.14
6: rm(a)
7: a
8: }, lazy = lazy)
9: rm(list = "a")
10: stopifnot(value(f) == 42L)
11: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[25]]
[[1]][[25]][[1]]
TestResult:
- Test:
- Title: 'future() - non-exported package objects'
- Tags: 'future', 'globals'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: if (requireNamespace("utils") && require("utils")) {
3: env <- pos.to.env(match("package:utils", search()))
4: ns <- getNamespace("utils")
5: privates <- setdiff(names(ns), names(env))
6: non_exported <- NULL
7: for (name in privates) {
8: if (exists(name, envir = ns, mode = "function", inherits = FALSE)) {
9: non_exported <- get(name, envir = ns, mode = "function",
10: inherits = FALSE)
11: }
12: }
13: stopifnot(is.function(non_exported))
14: f <- future({
15: non_exported
16: }, lazy = TRUE)
17: stopifnot("non_exported" %in% names(f$globals), identical(f$globals[["non_exported"]],
18: non_exported))
19: v <- value(f)
20: stopifnot(identical(v, non_exported))
21: }
22: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.109 secs
[[1]][[26]]
[[1]][[26]][[1]]
TestResult:
- Test:
- Title: 'future() - NSE '...''
- Tags: 'future', 'globals', '...'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: my_fcn <- function(...) {
3: globals <- globals::globalsByName("...", envir = environment())
4: f <- future({
5: fcn <- function() sum(...)
6: fcn()
7: }, envir = parent.frame(), globals = globals)
8: v <- value(f)
9: v
10: }
11: y <- my_fcn()
12: stopifnot(y == 0L)
13: y <- my_fcn(1:10)
14: stopifnot(identical(y, 55L))
15: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[27]]
[[1]][[27]][[1]]
TestResult:
- Test:
- Title: 'resolved() on lazy futures'
- Tags: 'resolved', 'lazy'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f <- future(42, lazy = TRUE)
3: while (!resolved(f)) {
4: Sys.sleep(0.1)
5: }
6: v <- value(f)
7: stopifnot(identical(v, 42))
8: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[28]]
[[1]][[28]][[1]]
TestResult:
- Test:
- Title: 'demo("mandelbrot", package = "future")'
- Tags: 'demo', 'mandelbrot'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: if (getRversion() <= "3.2.0") {
3: message("Test requires R (>= 3.2.0). Skipping")
4: return()
5: }
6: options(future.demo.mandelbrot.nrow = 2L)
7: options(future.demo.mandelbrot.resolution = 50L)
8: options(future.demo.mandelbrot.delay = FALSE)
9: on.exit(grDevices::graphics.off())
10: demo("mandelbrot", package = "future", ask = FALSE)
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(value = NULL, visible = FALSE)
- Visible: FALSE
- Captured output:
1: ''
2: ''
3: ' demo(mandelbrot)'
4: ' ---- ~~~~~~~~~~'
5: ''
6: '> library("future")'
7: ''
8: '> library("graphics")'
9: ''
10: '> plot_what_is_done <- function(counts) {'
11: '+ for (kk in seq_along(counts)) {'
12: '+ f <- counts[[kk]]'
13: '+ '
14: '+ ## Already plotted?'
15: '+ if (!inherits(f, "Future")) next'
16: '+ '
17: '+ ## Not resolved?'
18: '+ if (!resolved(f)) next'
19: '+ '
20: '+ message(sprintf("Plotting tile #%d of %d ...", kk, n))'
21: '+ counts[[kk]] <- value(f)'
22: '+ screen(kk)'
23: '+ plot(counts[[kk]])'
24: '+ }'
25: '+ '
26: '+ counts'
27: '+ }'
28: ''
29: '> ## Options'
30: '> region <- getOption("future.demo.mandelbrot.region", 1L)'
31: ''
32: '> if (!is.list(region)) {'
33: '+ if (region == 1L) {'
34: '+ region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)'
35: '+ } else if (region == 2L) {'
36: '+ region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)'
37: '+ } else if (region == 3L) {'
38: '+ region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)'
39: '+ }'
40: '+ }'
41: ''
42: '> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)'
43: ''
44: '> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)'
45: ''
46: '> delay <- getOption("future.demo.mandelbrot.delay", interactive())'
47: ''
48: '> if (isTRUE(delay)) {'
49: '+ delay <- function(counts) Sys.sleep(1.0)'
50: '+ } else if (!is.function(delay)) {'
51: '+ delay <- function(counts) {}'
52: '+ }'
53: ''
54: '> ## Generate Mandelbrot tiles to be computed'
55: '> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,'
56: '+ side = region$side, nrow = nrow,'
57: '+ resolution = resolution)'
58: ''
59: '> if (interactive()) {'
60: '+ dev.new()'
61: '+ plot.new()'
62: '+ split.screen(dim(Cs))'
63: '+ for (ii in seq_along(Cs)) {'
64: '+ screen(ii)'
65: '+ par(mar = c(0, 0, 0, 0))'
66: '+ text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)'
67: '+ }'
68: '+ } else {'
69: '+ split.screen(dim(Cs))'
70: '+ }'
71: '[1] 1 2 3 4'
72: ''
73: '> ## Create all Mandelbrot tiles via lazy futures'
74: '> n <- length(Cs)'
75: ''
76: '> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)'
77: ''
78: '> counts <- lapply(seq_along(Cs), FUN=function(ii) {'
79: '+ message(" ", ii, appendLF = FALSE)'
80: '+ C <- Cs[[ii]]'
81: '+ future({'
82: '+ message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)'
83: '+ fit <- mandelbrot(C)'
84: '+ '
85: '+ ## Emulate slowness'
86: '+ delay(fit)'
87: '+ '
88: '+ message(" done")'
89: '+ fit'
90: '+ }, lazy = TRUE)'
91: '+ })'
92: ''
93: '> message(".")'
94: ''
95: '> ## Calculate and plot tiles'
96: '> repeat {'
97: '+ counts <- plot_what_is_done(counts)'
98: '+ if (!any(sapply(counts, FUN = inherits, "Future"))) break'
99: '+ }'
100: ''
101: '> close.screen()'
102: '[1] 1 2 3 4'
103: ''
104: '> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")'
- Success: TRUE
- Processing time: 0.499 secs
[[1]][[28]][[2]]
TestResult:
- Test:
- Title: 'demo("mandelbrot", package = "future")'
- Tags: 'demo', 'mandelbrot'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: if (getRversion() <= "3.2.0") {
3: message("Test requires R (>= 3.2.0). Skipping")
4: return()
5: }
6: options(future.demo.mandelbrot.nrow = 2L)
7: options(future.demo.mandelbrot.resolution = 50L)
8: options(future.demo.mandelbrot.delay = FALSE)
9: on.exit(grDevices::graphics.off())
10: demo("mandelbrot", package = "future", ask = FALSE)
11: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(value = NULL, visible = FALSE)
- Visible: FALSE
- Captured output:
1: ''
2: ''
3: ' demo(mandelbrot)'
4: ' ---- ~~~~~~~~~~'
5: ''
6: '> library("future")'
7: ''
8: '> library("graphics")'
9: ''
10: '> plot_what_is_done <- function(counts) {'
11: '+ for (kk in seq_along(counts)) {'
12: '+ f <- counts[[kk]]'
13: '+ '
14: '+ ## Already plotted?'
15: '+ if (!inherits(f, "Future")) next'
16: '+ '
17: '+ ## Not resolved?'
18: '+ if (!resolved(f)) next'
19: '+ '
20: '+ message(sprintf("Plotting tile #%d of %d ...", kk, n))'
21: '+ counts[[kk]] <- value(f)'
22: '+ screen(kk)'
23: '+ plot(counts[[kk]])'
24: '+ }'
25: '+ '
26: '+ counts'
27: '+ }'
28: ''
29: '> ## Options'
30: '> region <- getOption("future.demo.mandelbrot.region", 1L)'
31: ''
32: '> if (!is.list(region)) {'
33: '+ if (region == 1L) {'
34: '+ region <- list(xmid = -0.75, ymid = 0.0, side = 3.0)'
35: '+ } else if (region == 2L) {'
36: '+ region <- list(xmid = 0.283, ymid = -0.0095, side = 0.00026)'
37: '+ } else if (region == 3L) {'
38: '+ region <- list(xmid = 0.282989, ymid = -0.01, side = 3e-8)'
39: '+ }'
40: '+ }'
41: ''
42: '> nrow <- getOption("future.demo.mandelbrot.nrow", 3L)'
43: ''
44: '> resolution <- getOption("future.demo.mandelbrot.resolution", 400L)'
45: ''
46: '> delay <- getOption("future.demo.mandelbrot.delay", interactive())'
47: ''
48: '> if (isTRUE(delay)) {'
49: '+ delay <- function(counts) Sys.sleep(1.0)'
50: '+ } else if (!is.function(delay)) {'
51: '+ delay <- function(counts) {}'
52: '+ }'
53: ''
54: '> ## Generate Mandelbrot tiles to be computed'
55: '> Cs <- mandelbrot_tiles(xmid = region$xmid, ymid = region$ymid,'
56: '+ side = region$side, nrow = nrow,'
57: '+ resolution = resolution)'
58: ''
59: '> if (interactive()) {'
60: '+ dev.new()'
61: '+ plot.new()'
62: '+ split.screen(dim(Cs))'
63: '+ for (ii in seq_along(Cs)) {'
64: '+ screen(ii)'
65: '+ par(mar = c(0, 0, 0, 0))'
66: '+ text(x = 1 / 2, y = 1 / 2, sprintf("Future #%d\nunresolved", ii), cex = 2)'
67: '+ }'
68: '+ } else {'
69: '+ split.screen(dim(Cs))'
70: '+ }'
71: '[1] 1 2 3 4'
72: ''
73: '> ## Create all Mandelbrot tiles via lazy futures'
74: '> n <- length(Cs)'
75: ''
76: '> message(sprintf("Creating %d Mandelbrot tiles:", n), appendLF = FALSE)'
77: ''
78: '> counts <- lapply(seq_along(Cs), FUN=function(ii) {'
79: '+ message(" ", ii, appendLF = FALSE)'
80: '+ C <- Cs[[ii]]'
81: '+ future({'
82: '+ message(sprintf("Calculating tile #%d of %d ...", ii, n), appendLF = FALSE)'
83: '+ fit <- mandelbrot(C)'
84: '+ '
85: '+ ## Emulate slowness'
86: '+ delay(fit)'
87: '+ '
88: '+ message(" done")'
89: '+ fit'
90: '+ }, lazy = TRUE)'
91: '+ })'
92: ''
93: '> message(".")'
94: ''
95: '> ## Calculate and plot tiles'
96: '> repeat {'
97: '+ counts <- plot_what_is_done(counts)'
98: '+ if (!any(sapply(counts, FUN = inherits, "Future"))) break'
99: '+ }'
100: ''
101: '> close.screen()'
102: '[1] 1 2 3 4'
103: ''
104: '> message("SUGGESTION: Try to rerun this demo after changing strategy for how futures are resolved, e.g. plan(multisession).\n")'
- Success: TRUE
- Processing time: 0.998 secs
[[1]][[29]]
[[1]][[29]][[1]]
TestResult:
- Test:
- Title: 'nbrOfWorkers()'
- Tags: 'nbrOfWorkers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: n <- nbrOfWorkers()
3: message(sprintf("nbrOfWorkers: %g", n))
4: stopifnot(is.numeric(n), length(n) == 1L, n >= 1L)
5: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[30]]
[[1]][[30]][[1]]
TestResult:
- Test:
- Title: 'future() - preserve R options'
- Tags: 'future', 'options', 'reset', 'data.table'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: if (requireNamespace("data.table")) {
3: data.table <- data.table::data.table
4: for (kk in 1:2) {
5: f <- future(data.table())
6: v <- value(f)
7: print(v)
8: stopifnot(inherits(v, "data.frame"), inherits(v,
9: "data.table"), nrow(v) == 0L, ncol(v) == 0L)
10: }
11: }
12: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'Null data.table (0 rows and 0 cols)'
2: 'Null data.table (0 rows and 0 cols)'
- Success: TRUE
- Processing time: 0.281 secs
[[1]][[31]]
[[1]][[31]][[1]]
TestResult:
- Test:
- Title: 'future() - preserve R options'
- Tags: 'future', 'options', 'reset', 'ff'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: info <- Sys.info()
3: is_localhost <- value(future(identical(Sys.info(), info)))
4: if (is_localhost && requireNamespace("ff")) {
5: data <- ff::ff(1:12)
6: for (kk in 1:2) {
7: f <- future(data[4], packages = "ff")
8: v <- value(f)
9: print(v)
10: stopifnot(is.integer(v), length(v) == 1L, identical(v,
11: 4L))
12: }
13: }
14: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] 4'
2: '[1] 4'
- Success: TRUE
- Processing time: 0.218 secs
[[1]][[32]]
[[1]][[32]][[1]]
TestResult:
- Test:
- Title: 'plan()'
- Tags: 'plan'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: print(current_plan)
4: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: structure(function (..., envir = parent.frame()) , {, future <- SequentialFuture(..., envir = envir), if (!future$lazy) , future <- run(future), invisible(future), }, class = c("FutureStrategy", "sequential", "uniprocess", "future", , "function"), call = plan(sequential))
- Visible: FALSE
- Captured output:
1: 'sequential:'
2: '- args: function (..., envir = parent.frame())'
3: '- tweaked: FALSE'
4: '- call: plan(sequential)'
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[33]]
[[1]][[33]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<numeric>'
- Tags: 'plan', 'workers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: if (!inherits(current_plan, "multiprocess"))
4: return()
5: plan(current_plan, workers = 1L)
6: n <- nbrOfWorkers()
7: cat(sprintf("Number of workers: %d\n", n))
8: stopifnot(n == 1L)
9: f <- future(42L)
10: stopifnot(value(f) == 42L)
11: plan(current_plan, workers = 2L)
12: n <- nbrOfWorkers()
13: cat(sprintf("Number of workers: %d\n", n))
14: stopifnot(n == 2L)
15: f <- future(42L)
16: stopifnot(value(f) == 42L)
17: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[34]]
[[1]][[34]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<function>'
- Tags: 'plan', 'workers'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: n0 <- nbrOfWorkers()
4: if (!inherits(current_plan, "multiprocess"))
5: return()
6: workers_value <- eval(formals(current_plan)$workers)
7: workers <- function() workers_value
8: plan(current_plan, workers = workers)
9: n <- nbrOfWorkers()
10: cat(sprintf("Number of workers: %d\n", n))
11: stopifnot(n == n0)
12: f <- future(42L)
13: stopifnot(value(f) == 42L)
14: workers <- function() 1L
15: plan(current_plan, workers = workers)
16: n <- nbrOfWorkers()
17: cat(sprintf("Number of workers: %d\n", n))
18: stopifnot(n == 1L)
19: f <- future(42L)
20: stopifnot(value(f) == 42L)
21: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[35]]
[[1]][[35]][[1]]
TestResult:
- Test:
- Title: 'plan() - workers=<invalid>'
- Tags: 'plan', 'workers', 'exceptions'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: current_plan <- plan()
3: if (!inherits(current_plan, "multiprocess"))
4: return()
5: res <- tryCatch({
6: plan(current_plan, workers = 0L)
7: }, error = identity)
8: print(res)
9: stopifnot(inherits(res, "error"))
10: res <- tryCatch({
11: plan(current_plan, workers = NA_integer_)
12: }, error = identity)
13: print(res)
14: stopifnot(inherits(res, "error"))
15: res <- tryCatch({
16: plan(current_plan, workers = TRUE)
17: }, error = identity)
18: print(res)
19: stopifnot(inherits(res, "error"))
20: res <- tryCatch({
21: plan(current_plan, workers = NA_character_)
22: }, error = identity)
23: print(res)
24: stopifnot(inherits(res, "error"))
25: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: TRUE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[36]]
[[1]][[36]][[1]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.936 secs
[[1]][[36]][[2]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.827 secs
[[1]][[36]][[3]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.562 secs
[[1]][[36]][[4]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.530 secs
[[1]][[36]][[5]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.515 secs
[[1]][[36]][[6]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.515 secs
[[1]][[36]][[7]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.515 secs
[[1]][[36]][[8]]
TestResult:
- Test:
- Title: 'resolve()'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future({
3: Sys.sleep(0.5)
4: list(a = 1, b = 42L)
5: }, lazy = lazy)
6: res <- resolve(f, result = result, recursive = recursive)
7: stopifnot(identical(res, f))
8: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.515 secs
[[1]][[37]]
[[1]][[37]][[1]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[37]][[2]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[37]][[3]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[37]][[4]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: FALSE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[37]][[5]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[37]][[6]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: FALSE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.000 secs
[[1]][[37]][[7]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: FALSE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[37]][[8]]
TestResult:
- Test:
- Title: 'resolve() - run-time exception'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
2. result: [n = 2] c(FALSE, TRUE)
3. recursive: [n = 2] c(FALSE, TRUE)
=> Test combinations: 8 (= 2*2*2)
- Expression:
1: {
2: f <- future(list(a = 1, b = 42L, c = stop("Nah!")), lazy = lazy)
3: res <- resolve(f, result = result, recursive = recursive)
4: stopifnot(identical(res, f))
5: }
- Arguments tested:
1. lazy: TRUE
2. result: TRUE
3. recursive: TRUE
4. globals: TRUE
5. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[38]]
[[1]][[38]][[1]]
TestResult:
- Test:
- Title: 'resolve(<list of futures and values>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[38]][[2]]
TestResult:
- Test:
- Title: 'resolve(<list of futures and values>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[39]]
[[1]][[39]][[1]]
TestResult:
- Test:
- Title: 'resolve(<list of futures>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = !lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[39]][[2]]
TestResult:
- Test:
- Title: 'resolve(<list of futures>)'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: x <- list()
3: x$a <- future(1, lazy = lazy)
4: x$b <- future(2, lazy = !lazy)
5: x[[3]] <- 3
6: y <- resolve(x)
7: stopifnot(identical(y, x))
8: stopifnot(resolved(x$a))
9: stopifnot(resolved(x[["b"]]))
10: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[40]]
[[1]][[40]][[1]]
TestResult:
- Test:
- Title: 'resolve(<named matrix list of futures and values>) - time ordering'
- Tags: 'resolve', 'lazy'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: x <- list()
3: x$a <- future(1)
4: x$b <- future({
5: Sys.sleep(0.5)
6: 2
7: })
8: x[[4]] <- 4
9: dim(x) <- c(2, 2)
10: y <- resolve(x, idxs = 1)
11: stopifnot(identical(y, x))
12: stopifnot(resolved(x[[1]]))
13: y <- resolve(x, idxs = 2)
14: stopifnot(identical(y, x))
15: stopifnot(resolved(x[[2]]))
16: y <- resolve(x, idxs = 3)
17: stopifnot(identical(y, x))
18: y <- resolve(x, idxs = seq_along(x))
19: stopifnot(identical(y, x))
20: y <- resolve(x, idxs = names(x))
21: stopifnot(identical(y, x))
22: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.530 secs
[[1]][[41]]
[[1]][[41]][[1]]
TestResult:
- Test:
- Title: 'resolved() - assert non-blocking while launching lazy futures'
- Tags: 'resolved', 'lazy'
- Reset workers: TRUE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: message("Creating lazy futures:")
3: n <- min(3, nbrOfWorkers() + 1L)
4: xs <- as.list(1:n)
5: fs <- lapply(xs, FUN = function(kk) {
6: future({
7: Sys.sleep(kk)
8: kk
9: }, lazy = TRUE)
10: })
11: vs <- vector("list", length = length(fs))
12: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
13: print(ss)
14: stopifnot(all(ss == "created"))
15: rs <- rep(NA, times = length(fs))
16: for (ff in seq_along(fs)) {
17: for (kk in ff:length(fs)) {
18: message(sprintf("Checking if future #%d is resolved:",
19: kk))
20: rs[[kk]] <- resolved(fs[[kk]])
21: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
22: print(ss)
23: nbrOfFinished <- sum(ss == "finished")
24: if (inherits(fs[[kk]], "UniprocessFuture")) {
25: stopifnot(rs[[kk]])
26: stopifnot(ss[[kk]] == "finished")
27: }
28: else if (inherits(fs[[kk]], "MultiprocessFuture")) {
29: if (nbrOfWorkers() + ff - 1L + nbrOfFinished >=
30: kk) {
31: stopifnot(ss[[kk]] == "running")
32: }
33: else {
34: stopifnot(ss[[kk]] == "created")
35: }
36: stopifnot(!rs[[kk]])
37: }
38: }
39: message(sprintf("Waiting for future #%d to finish ... ",
40: ff), appendLF = FALSE)
41: vs[[ff]] <- value(fs[[ff]])
42: message("done")
43: rs[[ff]] <- resolved(fs[[ff]])
44: stopifnot(rs[ff])
45: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
46: stopifnot(ss[ff] == "finished")
47: nbrOfFinished <- sum(ss == "finished")
48: if (inherits(fs[[kk]], "UniprocessFuture")) {
49: stopifnot(nbrOfFinished == length(fs))
50: }
51: else {
52: stopifnot(nbrOfFinished == ff)
53: }
54: }
55: ss <- vapply(fs, FUN = function(f) f$state, NA_character_)
56: print(ss)
57: stopifnot(all(ss == "finished"))
58: message("Collecting values:")
59: vs <- value(fs)
60: str(vs)
61: stopifnot(identical(vs, xs))
62: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] "created" "created"'
2: '[1] "finished" "created" '
3: '[1] "finished" "finished"'
4: '[1] "finished" "finished"'
5: '[1] "finished" "finished"'
6: 'List of 2'
7: ' $ : int 1'
8: ' $ : int 2'
- Success: TRUE
- Processing time: 3.104 secs
[[1]][[42]]
[[1]][[42]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - seeds and preserving RNGkind'
- Tags: 'rng', 'seed'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: okind <- RNGkind()
3: seed <- c(407L, 1420090545L, 65713854L, -990249945L, 1780737596L,
4: -1213437427L, 1082168682L)
5: f <- future(42, seed = seed)
6: print(f)
7: stopifnot(identical(f$seed, seed))
8: stopifnot(identical(RNGkind()[1], okind[1]))
9: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: 'SequentialFuture:'
2: 'Label: '<none>''
3: 'Expression:'
4: '[1] 42'
5: 'Lazy evaluation: FALSE'
6: 'Asynchronous evaluation: FALSE'
7: 'Local evaluation: TRUE'
8: 'Environment: 0x000000000f945c90'
9: 'Capture standard output: TRUE'
10: 'Capture condition classes: 'condition' (excluding 'nothing')'
11: 'Globals: <none>'
12: 'Packages: <none>'
13: 'L'Ecuyer-CMRG RNG seed: c(407, 1420090545, 65713854, -990249945, 1780737596, -1213437427, 1082168682)'
14: 'Resolved: TRUE'
15: 'Value: 56 bytes of class 'numeric''
16: 'Early signaling: FALSE'
17: 'Owner process: c802a6ba-d71f-b860-c40c-08c750a7743a'
18: 'Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[43]]
[[1]][[43]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - future'
- Tags: 'rng', 'seed', 'lazy', 'future'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "future", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(3L, 0L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x00000000081a0ad8>'
147: '<environment: 0x00000000081dfaa0>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 3'
164: ''
165: '[[2]]'
166: '[1] 0'
167: ''
- Success: TRUE
- Processing time: 0.156 secs
[[1]][[43]][[2]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - future'
- Tags: 'rng', 'seed', 'lazy', 'future'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "future", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "future", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(0L, 3L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x00000000081a0ad8>'
147: '<environment: 0x00000000081dfaa0>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 0'
164: ''
165: '[[2]]'
166: '[1] 3'
167: ''
- Success: TRUE
- Processing time: 0.125 secs
[[1]][[44]]
[[1]][[44]][[1]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - %<-%'
- Tags: 'rng', 'seed', 'lazy', '%<-%'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "%<-%", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(3L, 2L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x00000000081a0ad8>'
147: '<environment: 0x00000000081dfaa0>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 3'
164: ''
165: '[[2]]'
166: '[1] 2'
167: ''
- Success: TRUE
- Processing time: 0.109 secs
[[1]][[44]][[2]]
TestResult:
- Test:
- Title: 'Random Number Generation (RNG) - %<-%'
- Tags: 'rng', 'seed', 'lazy', '%<-%'
- Reset workers: FALSE
- Arguments:
1. lazy: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: fsample <- function (x, size = 2L, seed = NULL, what = c("future",
3: "%<-%"), lazy = FALSE)
4: {
5: what <- match.arg(what)
6: .GlobalEnv <- globalenv()
7: oseed <- .GlobalEnv$.Random.seed
8: orng <- RNGkind("L'Ecuyer-CMRG")[1L]
9: on.exit(RNGkind(orng))
10: if (!is.null(seed)) {
11: on.exit({
12: if (is.null(oseed)) {
13: rm(list = ".Random.seed", envir = .GlobalEnv,
14: inherits = FALSE)
15: } else {
16: .GlobalEnv$.Random.seed <- oseed
17: }
18: }, add = TRUE)
19: set.seed(seed)
20: }
21: .seed <- .Random.seed
22: if (what == "future") {
23: fs <- list()
24: for (ii in seq_len(size)) {
25: .seed <- parallel::nextRNGStream(.seed)
26: fs[[ii]] <- future({
27: sample(x, size = 1L)
28: }, lazy = lazy, seed = .seed)
29: }
30: res <- value(fs)
31: }
32: else {
33: res <- listenv::listenv()
34: for (ii in seq_len(size)) {
35: .seed <- parallel::nextRNGStream(.seed)
36: res[[ii]] %<-% {
37: sample(x, size = 1L)
38: } %lazy% lazy %seed% .seed
39: }
40: res <- as.list(res)
41: }
42: res
43: }
44: dummy <- sample(0:3, size = 1L)
45: seed0 <- .Random.seed
46: y0 <- local({
47: print(unclass(plan))
48: utils::str(plan)
49: old_plan <- plan()
50: plan("sequential")
51: on.exit(plan(old_plan))
52: fsample(0:3, seed = 42L)
53: })
54: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
55: .GlobalEnv$.Random.seed <- seed0
56: y1 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
57: print(y1)
58: stopifnot(identical(y1, y0))
59: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
60: y2 <- fsample(0:3, seed = 42L, what = "%<-%", lazy = lazy)
61: print(y2)
62: stopifnot(identical(y2, y1))
63: stopifnot(identical(y2, y0))
64: stopifnot(identical(.GlobalEnv$.Random.seed, seed0))
65: y3 <- fsample(0:3, what = "%<-%", lazy = lazy)
66: print(y3)
67: }
- Arguments tested:
1. lazy: TRUE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: list(1L, 0L)
- Visible: FALSE
- Captured output:
1: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, '
2: ' .call = TRUE, .cleanup = TRUE, .init = TRUE) '
3: '{'
4: ' if (substitute) '
5: ' strategy <- substitute(strategy)'
6: ' if (is.logical(.skip)) '
7: ' stop_if_not(length(.skip) == 1L, !is.na(.skip))'
8: ' if (is.logical(.call)) '
9: ' stop_if_not(length(.call) == 1L, !is.na(.call))'
10: ' if (is.null(strategy) || identical(strategy, "next")) {'
11: ' strategy <- stack[[1L]]'
12: ' if (!inherits(strategy, "FutureStrategy")) {'
13: ' class(strategy) <- c("FutureStrategy", class(strategy))'
14: ' }'
15: ' stop_if_not(is.function(strategy))'
16: ' return(strategy)'
17: ' }'
18: ' else if (identical(strategy, "default")) {'
19: ' strategy <- getOption("future.plan", sequential)'
20: ' }'
21: ' else if (identical(strategy, "list")) {'
22: ' return(stack)'
23: ' }'
24: ' else if (identical(strategy, "reset")) {'
25: ' stack <<- defaultStack'
26: ' if (.cleanup) '
27: ' plan_cleanup()'
28: ' return(stack)'
29: ' }'
30: ' else if (identical(strategy, "pop")) {'
31: ' oldStack <- stack'
32: ' stack <<- stack[-1L]'
33: ' if (length(stack) == 0L) '
34: ' stack <<- defaultStack'
35: ' return(oldStack)'
36: ' }'
37: ' oldStack <- stack'
38: ' newStack <- NULL'
39: ' targs <- list(...)'
40: ' if (is.function(strategy)) {'
41: ' if (length(targs) > 0) {'
42: ' args <- c(list(strategy), targs, penvir = parent.frame())'
43: ' strategy <- do.call(tweak, args = args)'
44: ' }'
45: ' strategy <- list(strategy)'
46: ' }'
47: ' if (is.list(strategy)) {'
48: ' oldStack <- plan_set(strategy, skip = .skip, cleanup = .cleanup, '
49: ' init = .init)'
50: ' return(invisible(oldStack))'
51: ' }'
52: ' if (is.language(strategy)) {'
53: ' first <- as.list(strategy)[[1]]'
54: ' if (is.symbol(first)) {'
55: ' if (is.call(strategy)) {'
56: ' first <- get(as.character(first), mode = "function", '
57: ' envir = parent.frame(), inherits = TRUE)'
58: ' }'
59: ' else {'
60: ' first <- eval(first, envir = parent.frame(), '
61: ' enclos = baseenv())'
62: ' }'
63: ' if (is.list(first)) {'
64: ' strategies <- first'
65: ' res <- plan(strategies, substitute = FALSE, .cleanup = .cleanup, '
66: ' .init = .init)'
67: ' return(invisible(res))'
68: ' }'
69: ' if (is.function(first) && !inherits(first, "future")) {'
70: ' strategies <- eval(strategy, envir = parent.frame(), '
71: ' enclos = baseenv())'
72: ' if (is.list(strategies)) {'
73: ' for (kk in seq_along(strategies)) {'
74: ' strategy_kk <- strategies[[kk]]'
75: ' if (is.character(strategy_kk)) {'
76: ' strategy_kk <- tweak(strategy_kk, penvir = parent.frame())'
77: ' strategies[[kk]] <- strategy_kk'
78: ' }'
79: ' }'
80: ' newStack <- strategies'
81: ' stop_if_not(!is.null(newStack), is.list(newStack), '
82: ' length(newStack) >= 1L)'
83: ' }'
84: ' else if (is.function(strategies) && !inherits(strategies, '
85: ' "future")) {'
86: ' strategies <- list(strategies)'
87: ' newStack <- strategies'
88: ' stop_if_not(!is.null(newStack), is.list(newStack), '
89: ' length(newStack) >= 1L)'
90: ' }'
91: ' }'
92: ' }'
93: ' }'
94: ' if (is.null(newStack)) {'
95: ' if (is.symbol(strategy)) {'
96: ' strategy <- eval(strategy, envir = parent.frame(), '
97: ' enclos = baseenv())'
98: ' }'
99: ' else if (is.language(strategy)) {'
100: ' strategyT <- as.list(strategy)'
101: ' if (strategyT[[1]] == as.symbol("tweak")) {'
102: ' strategy <- eval(strategy, envir = parent.frame(), '
103: ' enclos = baseenv())'
104: ' }'
105: ' else {'
106: ' isSymbol <- sapply(strategyT, FUN = is.symbol)'
107: ' if (!all(isSymbol)) {'
108: ' strategy <- eval(strategyT[[1L]], envir = parent.frame(), '
109: ' enclos = baseenv())'
110: ' if (length(strategyT) > 1L) {'
111: ' args <- c(list(strategy), strategyT[-1L], '
112: ' penvir = parent.frame())'
113: ' strategy <- do.call(tweak, args = args)'
114: ' }'
115: ' }'
116: ' else {'
117: ' strategy <- eval(strategy, envir = parent.frame(), '
118: ' enclos = baseenv())'
119: ' }'
120: ' }'
121: ' }'
122: ' args <- c(list(strategy), targs, penvir = parent.frame())'
123: ' tstrategy <- do.call(tweak, args = args, quote = TRUE)'
124: ' newStack <- list(tstrategy)'
125: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
126: ' 1L)'
127: ' }'
128: ' if (!is.null(.call)) {'
129: ' call <- if (isTRUE(.call)) '
130: ' sys.call()'
131: ' else .call'
132: ' for (kk in seq_along(newStack)) {'
133: ' strategy <- newStack[[kk]]'
134: ' if (!is.null(attr(strategy, "call", exact = TRUE))) '
135: ' next'
136: ' attr(strategy, "call") <- call'
137: ' newStack[[kk]] <- strategy'
138: ' }'
139: ' stop_if_not(!is.null(newStack), is.list(newStack), length(newStack) >= '
140: ' 1L)'
141: ' }'
142: ' oldStack <- plan_set(newStack, skip = .skip, cleanup = .cleanup, '
143: ' init = .init)'
144: ' invisible(oldStack)'
145: '}'
146: '<bytecode: 0x00000000081a0ad8>'
147: '<environment: 0x00000000081dfaa0>'
148: 'function (strategy = NULL, ..., substitute = TRUE, .skip = FALSE, .call = TRUE, '
149: ' .cleanup = TRUE, .init = TRUE) '
150: '[[1]]'
151: '[1] 2'
152: ''
153: '[[2]]'
154: '[1] 0'
155: ''
156: '[[1]]'
157: '[1] 2'
158: ''
159: '[[2]]'
160: '[1] 0'
161: ''
162: '[[1]]'
163: '[1] 1'
164: ''
165: '[[2]]'
166: '[1] 0'
167: ''
- Success: TRUE
- Processing time: 0.094 secs
[[1]][[45]]
[[1]][[45]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - future() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: rng0 <- globalenv()$.Random.seed
3: f1 <- future(1)
4: stopifnot(identical(globalenv()$.Random.seed, rng0))
5: f2 <- future(2)
6: stopifnot(identical(globalenv()$.Random.seed, rng0))
7: v1 <- value(f1)
8: stopifnot(identical(v1, 1))
9: v2 <- value(f2)
10: stopifnot(identical(v2, 2))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[46]]
[[1]][[46]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - run() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1, lazy = TRUE)
3: f2 <- future(2, lazy = TRUE)
4: rng0 <- globalenv()$.Random.seed
5: f1 <- run(f1)
6: stopifnot(identical(globalenv()$.Random.seed, rng0))
7: f2 <- run(f2)
8: stopifnot(identical(globalenv()$.Random.seed, rng0))
9: v1 <- value(f1)
10: stopifnot(identical(v1, 1))
11: v2 <- value(f2)
12: stopifnot(identical(v2, 2))
13: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[47]]
[[1]][[47]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - result() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1)
3: f2 <- future(2)
4: rng0 <- globalenv()$.Random.seed
5: r1 <- result(f1)
6: stopifnot(identical(r1$value, 1))
7: stopifnot(identical(globalenv()$.Random.seed, rng0))
8: r2 <- result(f2)
9: stopifnot(identical(r2$value, 2))
10: stopifnot(identical(globalenv()$.Random.seed, rng0))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[48]]
[[1]][[48]][[1]]
TestResult:
- Test:
- Title: 'Orchestration Stability - value() does not update RNG state'
- Tags: 'orchestration', 'rng', 'seed', 'stealth'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f1 <- future(1)
3: f2 <- future(2)
4: rng0 <- globalenv()$.Random.seed
5: v1 <- value(f1)
6: stopifnot(identical(v1, 1))
7: stopifnot(identical(globalenv()$.Random.seed, rng0))
8: v2 <- value(f2)
9: stopifnot(identical(v2, 2))
10: stopifnot(identical(globalenv()$.Random.seed, rng0))
11: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
[[1]][[49]]
[[1]][[49]][[1]]
TestResult:
- Test:
- Title: 'future() - standard output'
- Tags: 'future', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: f <- future({
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: }, stdout = stdout)
19: r <- result(f)
20: str(r)
21: stopifnot(value(f) == 42L)
22: if (stdout) {
23: print(r)
24: message(sprintf("- stdout = %s", stdout))
25: stopifnot(identical(r$stdout, truth))
26: }
27: else {
28: print(r)
29: print(plan())
30: message(sprintf("- stdout = %s", stdout))
31: stopifnot(is.null(r$stdout) || r$stdout == "")
32: }
33: }
- Arguments tested:
1. stdout: FALSE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: 'List of 9'
3: ' $ value : int 42'
4: ' $ visible : logi TRUE'
5: ' $ stdout : NULL'
6: ' $ conditions: list()'
7: ' $ rng : logi FALSE'
8: ' $ started : POSIXct[1:1], format: "2023-02-07 06:03:46"'
9: ' $ finished : POSIXct[1:1], format: "2023-02-07 06:03:46"'
10: ' $ r_info :List of 4'
11: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
12: ' .. ..$ : int [1:3] 4 1 3'
13: ' ..$ os : chr "windows"'
14: ' ..$ os_name : chr "Windows"'
15: ' ..$ captures_utf8: logi FALSE'
16: ' $ version : chr "1.8"'
17: ' - attr(*, "class")= chr "FutureResult"'
18: 'FutureResult:'
19: 'value: 'integer''
20: 'visible: TRUE'
21: 'stdout: NULL'
22: 'conditions: [n = 0] '
23: 'RNG used: FALSE'
24: 'duration: 0.01559997 secs (started 2023-02-07 06:03:46)'
25: 'version: 1.8'
26: 'sequential:'
27: '- args: function (..., envir = parent.frame())'
28: '- tweaked: FALSE'
29: '- call: plan(sequential)'
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[49]][[2]]
TestResult:
- Test:
- Title: 'future() - standard output'
- Tags: 'future', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: f <- future({
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: }, stdout = stdout)
19: r <- result(f)
20: str(r)
21: stopifnot(value(f) == 42L)
22: if (stdout) {
23: print(r)
24: message(sprintf("- stdout = %s", stdout))
25: stopifnot(identical(r$stdout, truth))
26: }
27: else {
28: print(r)
29: print(plan())
30: message(sprintf("- stdout = %s", stdout))
31: stopifnot(is.null(r$stdout) || r$stdout == "")
32: }
33: }
- Arguments tested:
1. stdout: TRUE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: 'List of 9'
3: ' $ value : int 42'
4: ' $ visible : logi TRUE'
5: ' $ stdout : chr " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 3"| __truncated__'
6: ' $ conditions: list()'
7: ' $ rng : logi FALSE'
8: ' $ started : POSIXct[1:1], format: "2023-02-07 06:03:46"'
9: ' $ finished : POSIXct[1:1], format: "2023-02-07 06:03:46"'
10: ' $ r_info :List of 4'
11: ' ..$ version :Classes 'R_system_version', 'package_version', 'numeric_version' hidden list of 1'
12: ' .. ..$ : int [1:3] 4 1 3'
13: ' ..$ os : chr "windows"'
14: ' ..$ os_name : chr "Windows"'
15: ' ..$ captures_utf8: logi FALSE'
16: ' $ version : chr "1.8"'
17: ' - attr(*, "class")= chr "FutureResult"'
18: ' [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25'
19: '[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50'
20: ' int [1:50] 1 2 3 4 5 6 7 8 9 10 ...'
21: 'a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 '
22: '"Sepal.Length" "Sepal.Width" "Petal.Length" "Petal.Width" "Species"'
23: '"1" 5.1 3.5 1.4 0.2 "setosa"'
24: '"2" 4.9 3 1.4 0.2 "setosa"'
25: '"3" 4.7 3.2 1.3 0.2 "setosa"'
26: '"4" 4.6 3.1 1.5 0.2 "setosa"'
27: '"5" 5 3.6 1.4 0.2 "setosa"'
28: '"6" 5.4 3.9 1.7 0.4 "setosa"'
29: '"7" 4.6 3.4 1.4 0.3 "setosa"'
30: '"8" 5 3.4 1.5 0.2 "setosa"'
31: '"9" 4.4 2.9 1.4 0.2 "setosa"'
32: '"10" 4.9 3.1 1.5 0.1 "setosa"'
33: 'FutureResult:'
34: 'value: 'integer''
35: 'visible: TRUE'
36: 'stdout: character'
37: 'conditions: [n = 0] '
38: 'RNG used: FALSE'
39: 'duration: 0.01559997 secs (started 2023-02-07 06:03:46)'
40: 'version: 1.8'
- Success: TRUE
- Processing time: 0.047 secs
[[1]][[50]]
[[1]][[50]][[1]]
TestResult:
- Test:
- Title: '%<-% - standard output'
- Tags: '%<-%', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: v %<-% {
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: } %stdout% stdout
19: out <- utils::capture.output(y <- v)
20: stopifnot(y == 42L)
21: if (!stdout) {
22: stopifnot(out == "")
23: }
24: else {
25: print(out)
26: stopifnot(identical(out, truth_rows))
27: }
28: }
- Arguments tested:
1. stdout: FALSE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
- Success: TRUE
- Processing time: 0.109 secs
[[1]][[50]][[2]]
TestResult:
- Test:
- Title: '%<-% - standard output'
- Tags: '%<-%', 'stdout'
- Reset workers: FALSE
- Arguments:
1. stdout: [n = 2] c(FALSE, TRUE)
=> Test combinations: 2
- Expression:
1: {
2: truth_rows <- utils::capture.output({
3: print(1:50)
4: str(1:50)
5: cat(letters, sep = "-")
6: cat(1:6, collapse = "\n")
7: write.table(datasets::iris[1:10, ], sep = "\t")
8: })
9: truth <- paste0(paste(truth_rows, collapse = "\n"), "\n")
10: print(truth)
11: v %<-% {
12: print(1:50)
13: str(1:50)
14: cat(letters, sep = "-")
15: cat(1:6, collapse = "\n")
16: write.table(datasets::iris[1:10, ], sep = "\t")
17: 42L
18: } %stdout% stdout
19: out <- utils::capture.output(y <- v)
20: stopifnot(y == 42L)
21: if (!stdout) {
22: stopifnot(out == "")
23: }
24: else {
25: print(out)
26: stopifnot(identical(out, truth_rows))
27: }
28: }
- Arguments tested:
1. stdout: TRUE
2. lazy: FALSE
3. globals: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: '[1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25\n[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50\n int [1:50] 1 2 3 4 5 6 7 8 9 10 ...\na-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 \n\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"\n\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"\n\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"\n\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"\n\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"\n\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"\n\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"\n\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"\n\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"\n\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"\n\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"\n"'
2: ' [1] " [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25"'
3: ' [2] "[26] 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50"'
4: ' [3] " int [1:50] 1 2 3 4 5 6 7 8 9 10 ..." '
5: ' [4] "a-b-c-d-e-f-g-h-i-j-k-l-m-n-o-p-q-r-s-t-u-v-w-x-y-z1 2 3 4 5 6 " '
6: ' [5] "\"Sepal.Length\"\t\"Sepal.Width\"\t\"Petal.Length\"\t\"Petal.Width\"\t\"Species\"" '
7: ' [6] "\"1\"\t5.1\t3.5\t1.4\t0.2\t\"setosa\"" '
8: ' [7] "\"2\"\t4.9\t3\t1.4\t0.2\t\"setosa\"" '
9: ' [8] "\"3\"\t4.7\t3.2\t1.3\t0.2\t\"setosa\"" '
10: ' [9] "\"4\"\t4.6\t3.1\t1.5\t0.2\t\"setosa\"" '
11: '[10] "\"5\"\t5\t3.6\t1.4\t0.2\t\"setosa\"" '
12: '[11] "\"6\"\t5.4\t3.9\t1.7\t0.4\t\"setosa\"" '
13: '[12] "\"7\"\t4.6\t3.4\t1.4\t0.3\t\"setosa\"" '
14: '[13] "\"8\"\t5\t3.4\t1.5\t0.2\t\"setosa\"" '
15: '[14] "\"9\"\t4.4\t2.9\t1.4\t0.2\t\"setosa\"" '
16: '[15] "\"10\"\t4.9\t3.1\t1.5\t0.1\t\"setosa\"" '
- Success: TRUE
- Processing time: 0.031 secs
[[1]][[51]]
[[1]][[51]][[1]]
TestResult:
- Test:
- Title: 'value() - visibility'
- Tags: 'value', 'visibility'
- Reset workers: FALSE
- Arguments:
<none>
=> Test combinations: 1
- Expression:
1: {
2: f <- future(42)
3: res <- withVisible({
4: value(f)
5: })
6: v <- res$value
7: stopifnot(identical(v, 42))
8: stopifnot(res$visible)
9: f <- future(invisible(42))
10: res <- withVisible({
11: value(f)
12: })
13: v <- res$value
14: stopifnot(identical(v, 42))
15: stopifnot(!res$visible)
16: }
- Arguments tested:
1. lazy: FALSE
2. globals: TRUE
3. stdout: TRUE
- Local evaluation: TRUE
- Result:
- Value: NULL
- Visible: FALSE
- Captured output:
1: ''
- Success: TRUE
- Processing time: 0.016 secs
attr(,"plan")
sequential:
- args: function (..., envir = parent.frame())
- tweaked: FALSE
- call: plan(sequential)
attr(,"exit_code")
[1] 1
Total number of errors: 1
> proc.time()
user system elapsed
8.22 0.31 18.04
Flavor: r-oldrel-windows-ix86+x86_64