Running ‘Test-class.R’ [9s/142s]
  Running ‘check.R’ [8s/26s]
  Running ‘cli_fcn.R’
  Running ‘db_state.R’ [5s/11s]
  Running ‘evaluate_expr.R’
  Running ‘one-test.R’
  Running ‘progress.R’
  Running ‘test_db.R’
  Running ‘test_plans.R’ [3s/129s]
  Running ‘utils.R’
  Running ‘zzz.onLoad.R’ [6s/13s]
Running the tests in ‘tests/Test-class.R’ failed.
Complete output:
  > library(future.tests)
  > library(future)
  > 
  > lazy <- FALSE
  > global <- TRUE
  > stdout <- TRUE
  > value <- TRUE
  > recursive <- FALSE
  > 
  > tests <- load_tests()
  > message("Number of tests: ", length(tests))
  Number of tests: 41
  > 
  > df_tests <- do.call(rbind, tests)
  > print(df_tests)
                                                                  title
  1                                               future() - conditions
  2                                                   %<-% - conditions
  3                                                      Argument '...'
  4                                 Argument '...' from parent function
  5                                       Argument '...' - non existing
  6                                          Argument '...' - exception
  7                                           Early signaling of errors
  8                                           Early signaling of errors
  9                                           Early signaling of errors
  10                                          Early signaling of errors
  11                                        Early signaling of warnings
  12                                        Early signaling of warnings
  13                                        Early signaling of warnings
  14                                        Early signaling of warnings
  15                                        Early signaling of messages
  16                                        Early signaling of messages
  17                                        Early signaling of messages
  18                                        Early signaling of messages
  19                                   futureAssign() - lazy evaluation
  20                                   futureAssign() - lazy evaluation
  21                       futureAssign() - potential task name clashes
  22 futureAssign() - global variables with and without lazy evaluation
  23 futureAssign() - global variables with and without lazy evaluation
  24             futureAssign() - lazy evaluation via disposable option
  25             futureAssign() - lazy evaluation via disposable option
  26                                            %<-% - local evaluation
  27                                            %<-% - local evaluation
  28                          %<-% - local evaluation & global variable
  29                          %<-% - local evaluation & global variable
  30                                                      %<-% - errors
  31                                                      %<-% - errors
  32                                          %<-% - errors and listenv
  33                                          %<-% - errors and listenv
  34                                                        %<-% & %->%
  35                                                        %<-% & %->%
  36                                                      %<-% - nested
  37                                                       futureCall()
  38                                                       futureCall()
  39                                                       futureCall()
  40                                                       futureCall()
  41                               futureCall() - globals = list(a = 3)
  42                               futureCall() - globals = list(a = 3)
  43                                       futureCall() - globals = "a"
  44                                       futureCall() - globals = "a"
  45                                         resolved() on lazy futures
  46                             demo("mandelbrot", package = "future")
  47                             demo("mandelbrot", package = "future")
  48                                                     nbrOfWorkers()
  49                                                             plan()
  50                                         plan() - workers=<numeric>
  51                                        plan() - workers=<function>
  52                                         plan() - workers=<invalid>
  53                                                          resolve()
  54                                                          resolve()
  55                                                          resolve()
  56                                                          resolve()
  57                                                          resolve()
  58                                                          resolve()
  59                                                          resolve()
  60                                                          resolve()
  61                                     resolve() - run-time exception
  62                                     resolve() - run-time exception
  63                                     resolve() - run-time exception
  64                                     resolve() - run-time exception
  65                                     resolve() - run-time exception
  66                                     resolve() - run-time exception
  67                                     resolve() - run-time exception
  68                                     resolve() - run-time exception
  69                              resolve(<list of futures and values>)
  70                              resolve(<list of futures and values>)
  71                                         resolve(<list of futures>)
  72                                         resolve(<list of futures>)
  73 resolve(<named matrix list of futures and values>) - time ordering
  74      resolved() - assert non-blocking while launching lazy futures
  75                             Random Number Generation (RNG) - seeds
  76                            Random Number Generation (RNG) - future
  77                            Random Number Generation (RNG) - future
  78                              Random Number Generation (RNG) - %<-%
  79                              Random Number Generation (RNG) - %<-%
  80                                         future() - standard output
  81                                         future() - standard output
  82                                             %<-% - standard output
  83                                             %<-% - standard output
  84                                               value() - visibility
             tags  lazy earlySignal globals value recursive stdout
  1  future, ....    NA          NA      NA    NA        NA     NA
  2  %<-%, co....    NA          NA      NA    NA        NA     NA
  3     %<-%, ...    NA          NA      NA    NA        NA     NA
  4     %<-%, ...    NA          NA      NA    NA        NA     NA
  5     %<-%, ...    NA          NA      NA    NA        NA     NA
  6     %<-%, ...    NA          NA      NA    NA        NA     NA
  7  earlySig.... FALSE       FALSE      NA    NA        NA     NA
  8  earlySig....  TRUE       FALSE      NA    NA        NA     NA
  9  earlySig.... FALSE        TRUE      NA    NA        NA     NA
  10 earlySig....  TRUE        TRUE      NA    NA        NA     NA
  11 earlySig.... FALSE       FALSE      NA    NA        NA     NA
  12 earlySig....  TRUE       FALSE      NA    NA        NA     NA
  13 earlySig.... FALSE        TRUE      NA    NA        NA     NA
  14 earlySig....  TRUE        TRUE      NA    NA        NA     NA
  15 earlySig.... FALSE       FALSE      NA    NA        NA     NA
  16 earlySig....  TRUE       FALSE      NA    NA        NA     NA
  17 earlySig.... FALSE        TRUE      NA    NA        NA     NA
  18 earlySig....  TRUE        TRUE      NA    NA        NA     NA
  19 futureAs.... FALSE          NA      NA    NA        NA     NA
  20 futureAs....  TRUE          NA      NA    NA        NA     NA
  21 futureAssign    NA          NA      NA    NA        NA     NA
  22 futureAs.... FALSE          NA      NA    NA        NA     NA
  23 futureAs....  TRUE          NA      NA    NA        NA     NA
  24 futureAs.... FALSE          NA      NA    NA        NA     NA
  25 futureAs....  TRUE          NA      NA    NA        NA     NA
  26   %<-%, lazy FALSE          NA      NA    NA        NA     NA
  27   %<-%, lazy  TRUE          NA      NA    NA        NA     NA
  28 %<-%, la.... FALSE          NA      NA    NA        NA     NA
  29 %<-%, la....  TRUE          NA      NA    NA        NA     NA
  30 %<-%, la.... FALSE          NA      NA    NA        NA     NA
  31 %<-%, la....  TRUE          NA      NA    NA        NA     NA
  32 %<-%, la.... FALSE          NA      NA    NA        NA     NA
  33 %<-%, la....  TRUE          NA      NA    NA        NA     NA
  34 %<-%, %-.... FALSE          NA      NA    NA        NA     NA
  35 %<-%, %-....  TRUE          NA      NA    NA        NA     NA
  36 %<-%, nested    NA          NA      NA    NA        NA     NA
  37 futureCa.... FALSE          NA   FALSE    NA        NA     NA
  38 futureCa....  TRUE          NA   FALSE    NA        NA     NA
  39 futureCa.... FALSE          NA    TRUE    NA        NA     NA
  40 futureCa....  TRUE          NA    TRUE    NA        NA     NA
  41 futureCa.... FALSE          NA      NA    NA        NA     NA
  42 futureCa....  TRUE          NA      NA    NA        NA     NA
  43 futureCa.... FALSE          NA      NA    NA        NA     NA
  44 futureCa....  TRUE          NA      NA    NA        NA     NA
  45 resolved....    NA          NA      NA    NA        NA     NA
  46 demo, ma.... FALSE          NA      NA    NA        NA     NA
  47 demo, ma....  TRUE          NA      NA    NA        NA     NA
  48 nbrOfWorkers    NA          NA      NA    NA        NA     NA
  49         plan    NA          NA      NA    NA        NA     NA
  50 plan, wo....    NA          NA      NA    NA        NA     NA
  51 plan, wo....    NA          NA      NA    NA        NA     NA
  52 plan, wo....    NA          NA      NA    NA        NA     NA
  53 resolve,.... FALSE          NA      NA FALSE     FALSE     NA
  54 resolve,....  TRUE          NA      NA FALSE     FALSE     NA
  55 resolve,.... FALSE          NA      NA  TRUE     FALSE     NA
  56 resolve,....  TRUE          NA      NA  TRUE     FALSE     NA
  57 resolve,.... FALSE          NA      NA FALSE      TRUE     NA
  58 resolve,....  TRUE          NA      NA FALSE      TRUE     NA
  59 resolve,.... FALSE          NA      NA  TRUE      TRUE     NA
  60 resolve,....  TRUE          NA      NA  TRUE      TRUE     NA
  61 resolve,.... FALSE          NA      NA FALSE     FALSE     NA
  62 resolve,....  TRUE          NA      NA FALSE     FALSE     NA
  63 resolve,.... FALSE          NA      NA  TRUE     FALSE     NA
  64 resolve,....  TRUE          NA      NA  TRUE     FALSE     NA
  65 resolve,.... FALSE          NA      NA FALSE      TRUE     NA
  66 resolve,....  TRUE          NA      NA FALSE      TRUE     NA
  67 resolve,.... FALSE          NA      NA  TRUE      TRUE     NA
  68 resolve,....  TRUE          NA      NA  TRUE      TRUE     NA
  69 resolve,.... FALSE          NA      NA    NA        NA     NA
  70 resolve,....  TRUE          NA      NA    NA        NA     NA
  71 resolve,.... FALSE          NA      NA    NA        NA     NA
  72 resolve,....  TRUE          NA      NA    NA        NA     NA
  73 resolve,....    NA          NA      NA    NA        NA     NA
  74 resolved....    NA          NA      NA    NA        NA     NA
  75    rng, seed    NA          NA      NA    NA        NA     NA
  76 rng, see.... FALSE          NA      NA    NA        NA     NA
  77 rng, see....  TRUE          NA      NA    NA        NA     NA
  78 rng, see.... FALSE          NA      NA    NA        NA     NA
  79 rng, see....  TRUE          NA      NA    NA        NA     NA
  80 future, ....    NA          NA      NA    NA        NA  FALSE
  81 future, ....    NA          NA      NA    NA        NA   TRUE
  82 %<-%, stdout    NA          NA      NA    NA        NA  FALSE
  83 %<-%, stdout    NA          NA      NA    NA        NA   TRUE
  84 value, v....    NA          NA      NA    NA        NA     NA
  > 
  > message("Run first three tests ...")
  Run first three tests ...
  > 
  > library(future)
  > results <- run_tests(head(tests, 3L))
  > print(results)
  [[1]]
  TestResult:
  - Test:
    - Title: 'future() - conditions'
    - Tags: 'future', 'conditions'
    - Reset workers: FALSE
    - Arguments:
        <none>
      => Test combinations: 1
    - Expression:
        1: {
        2:     captureConditions <- function(...) {
        3:         conditions <- list()
        4:         withCallingHandlers(..., condition = function(c) {
        5:             conditions[[length(conditions) + 1L]] <<- c
        6:             if (inherits(c, "message")) {
        7:                 invokeRestart("muffleMessage")
        8:             }
        9:             else if (inherits(c, "warning")) {
       10:                 invokeRestart("muffleWarning")
       11:             }
       12:         })
       13:         conditions
       14:     }
       15:     truth <- captureConditions({
       16:         message("hello")
       17:         warning("whoops")
       18:         message("world")
       19:     })
       20:     f <- future({
       21:         print(1:3)
       22:         message("hello")
       23:         warning("whoops")
       24:         message("world")
       25:         42L
       26:     })
       27:     r <- result(f)
       28:     str(r)
       29:     stopifnot(value(f) == 42L)
       30:     conditions <- r$conditions
       31:     stopifnot(is.list(conditions), length(conditions) == 3L)
       32:     conditions <- lapply(conditions, FUN = function(c) c$condition)
       33:     for (kk in seq_along(conditions)) {
       34:         stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])), 
       35:             identical(conditions[[kk]]$message, truth[[kk]]$message))
       36:     }
       37:     conditions <- captureConditions(value(f))
       38:     stopifnot(is.list(conditions), length(conditions) == 3L)
       39:     for (kk in seq_along(conditions)) {
       40:         stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])), 
       41:             identical(conditions[[kk]]$message, truth[[kk]]$message))
       42:     }
       43: }
  - Arguments tested:
      <none>
  - Local evaluation: FALSE
  - Result:
    - Value: NULL
    - Visible: FALSE
  - Captured output:
      1: 'List of 8'
      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: "2020-07-06 13:12:00"'
     26: ' $ finished  : POSIXct[1:1], format: "2020-07-06 13:12:01"'
     27: ' $ version   : chr "1.8"'
     28: ' - attr(*, "class")= chr "FutureResult"'
     29: '[1] 1 2 3'
     30: '[1] 1 2 3'
  - Success: TRUE
  - Processing time: 0.521 secs
  
  [[2]]
  TestResult:
  - Test:
    - Title: '%<-% - conditions'
    - Tags: '%<-%', 'conditions'
    - Reset workers: FALSE
    - Arguments:
        <none>
      => Test combinations: 1
    - Expression:
        1: {
        2:     captureConditions <- function(...) {
        3:         conditions <- list()
        4:         withCallingHandlers(..., condition = function(c) {
        5:             conditions[[length(conditions) + 1L]] <<- c
        6:             if (inherits(c, "message")) {
        7:                 invokeRestart("muffleMessage")
        8:             }
        9:             else if (inherits(c, "warning")) {
       10:                 invokeRestart("muffleWarning")
       11:             }
       12:         })
       13:         conditions
       14:     }
       15:     truth <- captureConditions({
       16:         message("hello")
       17:         warning("whoops")
       18:         message("world")
       19:     })
       20:     v %<-% {
       21:         print(1:3)
       22:         message("hello")
       23:         warning("whoops")
       24:         message("world")
       25:         42L
       26:     }
       27:     conditions <- captureConditions(v)
       28:     stopifnot(v == 42L)
       29:     stopifnot(is.list(conditions), length(conditions) == 3L)
       30:     for (kk in seq_along(conditions)) {
       31:         stopifnot(identical(class(conditions[[kk]]), class(truth[[kk]])), 
       32:             identical(conditions[[kk]]$message, truth[[kk]]$message))
       33:     }
       34: }
  - Arguments tested:
      <none>
  - Local evaluation: FALSE
  - Result:
    - Value: NULL
    - Visible: FALSE
  - Captured output:
      1: '[1] 1 2 3'
  - Success: TRUE
  - Processing time: 0.052 secs
  
  [[3]]
  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:
      <none>
  - Local evaluation: FALSE
  - Result:
    - Value: NULL
    - Visible: FALSE
  - Captured output:
      1: '[1] 6'
  - Success: TRUE
  - Processing time: 0.050 secs
  
  > 
  > df_results <- do.call(rbind, results)
  > print(df_results)
                    title            time success
  1 future() - conditions 0.52078795 secs    TRUE
  2     %<-% - conditions 0.05185151 secs    TRUE
  3        Argument '...' 0.05034614 secs    TRUE
  > 
  > message("Run first three tests ... DONE")
  Run first three tests ... DONE
  > 
  > 
  > message("Run a few tests across different future plans ...")
  Run a few tests across different future plans ...
  > 
  > tests <- tests[seq(from = 1L, to = length(tests), length.out = 5L)]
  > 
  > library(future)
  > 
  > value <- TRUE
  > recursive <- FALSE
  > 
  > ntests <- length(tests)
  > 
  > 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(sequential)
  
  [[2]]
  plan(multisession, workers = 1L)
  
  [[3]]
  plan(multisession, workers = 2L)
  
  > 
  > res <- along_test_plans({
  +   res_plan <- list()
  +   for (lazy in c(FALSE, TRUE)) {
  +     for (global in c(FALSE, TRUE)) {
  +       for (stdout in c(FALSE, TRUE)) {
  +         args <- c(lazy = lazy, global = global, stdout = stdout)
  +         args_tag <- paste(sprintf("%s=%s", names(args), args), collapse = ",")
  +         message(sprintf("Running tests with (%s) ...", args_tag))
  +     
  +         tests_tt <- subset_tests(tests, args = args)
  +         ntests_tt <- length(tests_tt)
  +         message(sprintf(" - Number of tests: %d out of %d", ntests_tt, ntests))
  +       
  +         res_tt <- run_tests(tests_tt)
  +         print(res_tt)
  + 	stopifnot(is.list(res_tt))
  +     
  +         res_plan[[args_tag]] <- res_tt
  +   
  +         message(sprintf("Running tests with (%s) ... DONE", args_tag))
  +       }
  +     }
  +   }
  +   stopifnot(is.list(res_plan), length(res_plan) == 2*2*2)
  +   res_plan
  + })
  Evaluating expression under future plan #1 of 3 ...
  sequential:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: FALSE
  - call: plan(sequential)
  Evaluating expression under future plan #1 of 3 ... DONE
  Evaluating expression under future plan #2 of 3 ...
  multisession:
  - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = 1L, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: TRUE
  - call: plan(multisession, workers = 1L)
  Evaluating expression under future plan #2 of 3 ... DONE
  Evaluating expression under future plan #3 of 3 ...
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 35418 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=Test-class.R:1967688:gannet.stats.ox.ac.uk:ripley' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpIJzhu8/working_dir/RtmpKmyAhw/future.parent=1967688.1e064859dba72a.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=35418 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 1969276) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
  Calls: along_test_plans ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted
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 (value, ...)
  - 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 (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = 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 (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, persistent = FALSE, workers = 1L, gc = FALSE, earlySignal = FALSE, label = NULL, ...)
  - tweaked: TRUE
  - call: plan(multisession, workers = 1L)
  Evaluating expression under future plan #3 of 4 ... DONE
  Evaluating expression under future plan #4 of 4 ...
  Error in get(name, envir = asNamespace(pkg), inherits = FALSE) : 
    object '.slaveRSOCK' not found
  Calls: ::: -> get
  Execution halted
  Error in makeRestartList(...) : 
    Failed to launch and connect to R worker on local machine 'localhost' from local machine 'gannet.stats.ox.ac.uk'.
   * The error produced by socketConnection() was: 'reached elapsed time limit' (which suggests that the connection timeout of 120 seconds (argument 'connectTimeout') kicked in)
   * The localhost socket connection that failed to connect to the R worker used port 36922 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: '/data/gannet/ripley/R/R-devel/bin/Rscript' --default-packages=datasets,utils,grDevices,graphics,stats,methods -e '#label=test_plans.R:1991043:gannet.stats.ox.ac.uk:ripley' -e 'try(suppressWarnings(cat(Sys.getpid(),file="/tmp/RtmpIJzhu8/working_dir/RtmpCFtDJw/future.parent=1991043.1e618366a3f0a8.pid")), silent = TRUE)' -e 'parallel:::.slaveRSOCK()' MASTER=localhost PORT=36922 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 1991565) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: Set 'outfile=NULL' to see output from worker.
  Calls: along_test_plans ... tryCatchList -> tryCatchOne -> <Anonymous> -> <Anonymous>
  Execution halted