Running 'Test-class.R' [6s]
  Running 'check.R' [14s]
  Running 'cli_fcn.R' [2s]
  Running 'db_state.R' [3s]
  Running 'evaluate_expr,ff.R' [2s]
  Running 'evaluate_expr.R' [2s]
  Running 'one-test.R' [168s]
  Running 'progress.R' [2s]
  Running 'test_db.R' [4s]
  Running 'test_plans.R' [160s]
  Running 'utils.R' [2s]
  Running 'zzz.onLoad.R' [6s]
Running the tests in 'tests/one-test.R' failed.
Complete output:
  > library(future.tests)
  > library(future)
  > 
  > lazy <- FALSE
  > global <- TRUE
  > stdout <- TRUE
  > value <- TRUE
  > recursive <- FALSE
  > 
  > tests <- load_tests()
  > 
  > test <- tests[[1]]
  > print(test)
  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: }
  > 
  > result <- run_test(test)
  > print(result)
  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:
      <none>
  - Local evaluation: TRUE
  - Result:
    - Value: NULL
    - Visible: FALSE
  - Captured output:
      1: 'List of 11'
      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: ' $ globalenv   : NULL'
     26: ' $ started     : POSIXct[1:1], format: "2024-03-23 14:26:21"'
     27: ' $ finished    : POSIXct[1:1], format: "2024-03-23 14:26:21"'
     28: ' $ session_uuid: chr "110c7741-2f72-f172-adf3-45ae6e78c7ee"'
     29: '  ..- attr(*, "source")=List of 5'
     30: '  .. ..$ host  : Named chr "CRANWIN3"'
     31: '  .. .. ..- attr(*, "names")= chr "COMPUTERNAME"'
     32: '  .. ..$ info  : Named chr [1:8] "Windows" "Server x64" "build 20348" "CRANWIN3" ...'
     33: '  .. .. ..- attr(*, "names")= chr [1:8] "sysname" "release" "version" "nodename" ...'
     34: '  .. ..$ pid   : int 184756'
     35: '  .. ..$ time  : POSIXct[1:1], format: "2024-03-23 14:26:18"'
     36: '  .. ..$ random: int 2147483647'
     37: ' $ r_info      :List of 4'
     38: '  ..$ version      :Classes 'R_system_version', 'package_version', 'numeric_version'  hidden list of 1'
     39: '  .. ..$ : int [1:3] 4 4 0'
     40: '  ..$ os           : chr "windows"'
     41: '  ..$ os_name      : chr "Windows"'
     42: '  ..$ captures_utf8: logi TRUE'
     43: ' $ version     : chr "1.8"'
     44: ' - attr(*, "class")= chr "FutureResult"'
     45: '[1] 1 2 3'
     46: '[1] 1 2 3'
  - Success: TRUE
  - Processing time: 0.136 secs
  > 
  > proc.time()
     user  system elapsed 
     3.28    0.09    3.34 
Running the tests in 'tests/test_plans.R' failed.
Complete output:
  > library(future.tests)
  > library(future)
  > 
  > test_plans <- test_plans()
  > print(test_plans)
  list()
  > 
  > add_test_plan(plan(future:::constant))
  > add_test_plan(plan(sequential))
  > add_test_plan(plan(multisession, workers = 1L))
  > add_test_plan(plan(multisession, workers = 2L))
  > 
  > test_plans <- test_plans()
  > print(test_plans)
  [[1]]
  plan(future:::constant)
  
  [[2]]
  plan(sequential)
  
  [[3]]
  plan(multisession, workers = 1L)
  
  [[4]]
  plan(multisession, workers = 2L)
  
  > stopifnot(length(test_plans) == 4L)
  > 
  > res <- along_test_plans({ 42L })
  Evaluating expression under future plan #1 of 4 ...
  constant:
  - args: function (..., workers = "<NULL>")
  - tweaked: FALSE
  - call: plan(future:::constant)
  Evaluating expression under future plan #1 of 4 ... DONE
  Evaluating expression under future plan #2 of 4 ...
  sequential:
  - args: function (..., envir = parent.frame(), workers = "<NULL>")
  - tweaked: FALSE
  - call: plan(sequential)
  Evaluating expression under future plan #2 of 4 ... DONE
  Evaluating expression under future plan #3 of 4 ...
  multisession:
  - args: function (..., workers = 1L, envir = parent.frame())
  - tweaked: TRUE
  - call: plan(multisession, workers = 1L)
  Evaluating expression under future plan #3 of 4 ... DONE
  Evaluating expression under future plan #4 of 4 ...
  multisession:
  - args: function (..., workers = 2L, envir = parent.frame())
  - tweaked: TRUE
  - call: plan(multisession, workers = 2L)
  Evaluating expression under future plan #4 of 4 ... DONE
  > print(res)
  [[1]]
  [1] 42
  
  [[2]]
  [1] 42
  
  [[3]]
  [1] 42
  
  [[4]]
  [1] 42
  
  > 
  > proc.time()
     user  system elapsed 
     1.78    0.15    2.93