Running 'spelling.R' [0s]
  Running 'testthat.R' [35s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(adept)
  > 
  > test_check("adept")
  -- 1. Error: Example 5(a). Setting: no noise in signal, all pattern occurences o
  Failed to launch and connect to R worker on local machine 'localhost' from local machine 'CRANWIN'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 11748 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
   * The localhost socket connection that failed to connect to the R worker used port 11748 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: "D:/RCompile/recent/R-36~1.1/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=testthat.R:64416:CRANWIN:CRAN" -e "try(cat(Sys.getpid(),file=\"D:/temp/RtmpiQLJL5/future.parent=64416.fba0612265e6.pid\"), silent = TRUE)" -e "parallel:::.slaveRSOCK()" MASTER=localhost PORT=11748 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 35628) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).
  1: segmentPattern(x = x, x.fs = 1, template = template, pattern.dur.seq = pattern.dur.seq, 
         similarity.measure = "cor", x.cut = TRUE, x.cut.vl = 6000, run.parallel = TRUE, 
         run.parallel.cores = 2, compute.template.idx = TRUE) at testthat/test-segmentPattern.R:575
  2: plan(multiprocess, workers = run.parallel.cores)
  3: plan_set(newStack, skip = .skip, cleanup = .cleanup, init = .init)
  4: plan_init()
  5: evaluator(NA, label = "future-plan-test", globals = FALSE, lazy = FALSE)
  6: fun(expr = expr, envir = envir, substitute = FALSE, lazy = lazy, seed = seed, globals = globals, 
         workers = workers, gc = gc, earlySignal = earlySignal, label = label, ...)
  7: ClusterRegistry("start", workers = workers)
  8: makeCluster(workers, ...)
  9: makeClusterPSOCK(workers, ...)
  10: makeNode(workers[[ii]], port = port, ..., rank = ii, verbose = verbose)
  11: (function() {
         setTimeLimit(elapsed = connectTimeout)
         on.exit(setTimeLimit(elapsed = Inf))
         warnings <- list()
         tryCatch({
             withCallingHandlers({
                 socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, 
                     open = "a+b", timeout = timeout)
             }, warning = function(w) {
                 if (verbose) {
                     message(sprintf("%sDetected a warning from socketConnection(): %s", 
                       verbose_prefix, sQuote(conditionMessage(w))))
                 }
                 warnings <<- c(warnings, list(w))
             })
         }, error = function(ex) {
             setTimeLimit(elapsed = Inf)
             machineType <- if (localMachine) 
                 "local"
             else "remote"
             msg <- sprintf("Failed to launch and connect to R worker on %s machine %s from local machine %s.\n", 
                 machineType, sQuote(worker), sQuote(Sys.info()[["nodename"]]))
             cmsg <- conditionMessage(ex)
             if (grepl(gettext("reached elapsed time limit"), cmsg)) {
                 msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s (which suggests that the connection timeout of %.0f seconds (argument 'connectTimeout') kicked in)\n", 
                     sQuote(cmsg), connectTimeout))
             }
             else {
                 msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s\n", 
                     sQuote(cmsg)))
             }
             if (length(warnings) > 0) {
                 msg <- c(msg, sprintf(" * In addition, socketConnection() produced %d warning(s):\n", 
                     length(warnings)))
                 for (kk in seq_along(warnings)) {
                     cmsg <- conditionMessage(warnings[[kk]])
                     if (grepl("port [0-9]+ cannot be opened", cmsg)) {
                       msg <- c(msg, sprintf("   - Warning #%d: %s (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)\n", 
                         kk, sQuote(cmsg)))
                     }
                     else {
                       msg <- c(msg, sprintf("   - Warning #%d: %s\n", kk, sQuote(cmsg)))
                     }
                 }
             }
             msg <- c(msg, sprintf(" * The localhost socket connection that failed to connect to the R worker used port %d using a communication timeout of %.0f seconds and a connection timeout of %.0f seconds.\n", 
                 port, timeout, connectTimeout))
             msg <- c(msg, sprintf(" * Worker launch call: %s.\n", local_cmd))
             pid <- readWorkerPID(pidfile)
             if (!is.null(pid)) {
                 if (verbose) 
                     message(sprintf("Killing worker process (PID %d) if still alive", 
                       pid))
                 success <- pid_kill(pid)
                 if (verbose) 
                     message(sprintf("Worker (PID %d) was successfully killed: %s", pid, 
                       success))
                 msg <- c(msg, sprintf(" * Worker (PID %d) was successfully killed: %s\n", 
                     pid, success))
             }
             else if (localMachine) {
                 msg <- c(msg, sprintf(" * Failed to kill local worker because it's PID is could not be identified.\n"))
             }
             suggestions <- NULL
             if (!verbose) {
                 suggestions <- c(suggestions, "Set 'verbose=TRUE' to see more details.")
             }
             if (.Platform$OS.type == "windows") {
                 if (is_worker_output_visible) {
                     suggestions <- c(suggestions, "On Windows, to see output from worker, set 'outfile=NULL' and run R from a terminal (not a GUI).")
                 }
                 else {
                     suggestions <- c(suggestions, "On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).")
                 }
             }
             else {
                 if (!is_worker_output_visible) {
                     suggestions <- c(suggestions, "Set 'outfile=NULL' to see output from worker.")
                 }
             }
             if (is.character(rshlogfile)) {
                 smsg <- sprintf("Inspect the content of log file %s for %s.", sQuote(rshlogfile), 
                     sQuote(rshcmd))
                 lmsg <- tryCatch(readLines(rshlogfile, n = 15L, warn = FALSE), error = function(ex) NULL)
                 if (length(lmsg) > 0) {
                     lmsg <- sprintf("     %2d: %s", seq_along(lmsg), lmsg)
                     smsg <- sprintf("%s The first %d lines are:\n%s", smsg, length(lmsg), 
                       paste(lmsg, collapse = "\n"))
                 }
                 suggestions <- c(suggestions, smsg)
             }
             else {
                 suggestions <- c(suggestions, sprintf("Set 'rshlogfile=TRUE' to enable logging for %s.", 
                     sQuote(rshcmd)))
             }
             if (!localMachine && revtunnel && isTRUE(attr(rshcmd, "OpenSSH_for_Windows"))) {
                 suggestions <- c(suggestions, sprintf("The 'rshcmd' (%s) used may not support reverse tunneling (revtunnel = TRUE). See ?future::makeClusterPSOCK for alternatives.\n", 
                     rshcmd_label))
             }
             if (length(suggestions) > 0) {
                 suggestions <- sprintf("   - Suggestion #%d: %s\n", seq_along(suggestions), 
                     suggestions)
                 msg <- c(msg, " * Troubleshooting suggestions:\n", suggestions)
             }
             msg <- paste(msg, collapse = "")
             ex$message <- msg
             local({
                 oopts <- options(warning.length = 2000L)
                 on.exit(options(oopts))
                 stop(ex)
             })
         })
     })()
  12: tryCatch({
         withCallingHandlers({
             socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, 
                 open = "a+b", timeout = timeout)
         }, warning = function(w) {
             if (verbose) {
                 message(sprintf("%sDetected a warning from socketConnection(): %s", verbose_prefix, 
                     sQuote(conditionMessage(w))))
             }
             warnings <<- c(warnings, list(w))
         })
     }, error = function(ex) {
         setTimeLimit(elapsed = Inf)
         machineType <- if (localMachine) 
             "local"
         else "remote"
         msg <- sprintf("Failed to launch and connect to R worker on %s machine %s from local machine %s.\n", 
             machineType, sQuote(worker), sQuote(Sys.info()[["nodename"]]))
         cmsg <- conditionMessage(ex)
         if (grepl(gettext("reached elapsed time limit"), cmsg)) {
             msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s (which suggests that the connection timeout of %.0f seconds (argument 'connectTimeout') kicked in)\n", 
                 sQuote(cmsg), connectTimeout))
         }
         else {
             msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s\n", 
                 sQuote(cmsg)))
         }
         if (length(warnings) > 0) {
             msg <- c(msg, sprintf(" * In addition, socketConnection() produced %d warning(s):\n", 
                 length(warnings)))
             for (kk in seq_along(warnings)) {
                 cmsg <- conditionMessage(warnings[[kk]])
                 if (grepl("port [0-9]+ cannot be opened", cmsg)) {
                     msg <- c(msg, sprintf("   - Warning #%d: %s (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)\n", 
                       kk, sQuote(cmsg)))
                 }
                 else {
                     msg <- c(msg, sprintf("   - Warning #%d: %s\n", kk, sQuote(cmsg)))
                 }
             }
         }
         msg <- c(msg, sprintf(" * The localhost socket connection that failed to connect to the R worker used port %d using a communication timeout of %.0f seconds and a connection timeout of %.0f seconds.\n", 
             port, timeout, connectTimeout))
         msg <- c(msg, sprintf(" * Worker launch call: %s.\n", local_cmd))
         pid <- readWorkerPID(pidfile)
         if (!is.null(pid)) {
             if (verbose) 
                 message(sprintf("Killing worker process (PID %d) if still alive", pid))
             success <- pid_kill(pid)
             if (verbose) 
                 message(sprintf("Worker (PID %d) was successfully killed: %s", pid, success))
             msg <- c(msg, sprintf(" * Worker (PID %d) was successfully killed: %s\n", 
                 pid, success))
         }
         else if (localMachine) {
             msg <- c(msg, sprintf(" * Failed to kill local worker because it's PID is could not be identified.\n"))
         }
         suggestions <- NULL
         if (!verbose) {
             suggestions <- c(suggestions, "Set 'verbose=TRUE' to see more details.")
         }
         if (.Platform$OS.type == "windows") {
             if (is_worker_output_visible) {
                 suggestions <- c(suggestions, "On Windows, to see output from worker, set 'outfile=NULL' and run R from a terminal (not a GUI).")
             }
             else {
                 suggestions <- c(suggestions, "On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).")
             }
         }
         else {
             if (!is_worker_output_visible) {
                 suggestions <- c(suggestions, "Set 'outfile=NULL' to see output from worker.")
             }
         }
         if (is.character(rshlogfile)) {
             smsg <- sprintf("Inspect the content of log file %s for %s.", sQuote(rshlogfile), 
                 sQuote(rshcmd))
             lmsg <- tryCatch(readLines(rshlogfile, n = 15L, warn = FALSE), error = function(ex) NULL)
             if (length(lmsg) > 0) {
                 lmsg <- sprintf("     %2d: %s", seq_along(lmsg), lmsg)
                 smsg <- sprintf("%s The first %d lines are:\n%s", smsg, length(lmsg), 
                     paste(lmsg, collapse = "\n"))
             }
             suggestions <- c(suggestions, smsg)
         }
         else {
             suggestions <- c(suggestions, sprintf("Set 'rshlogfile=TRUE' to enable logging for %s.", 
                 sQuote(rshcmd)))
         }
         if (!localMachine && revtunnel && isTRUE(attr(rshcmd, "OpenSSH_for_Windows"))) {
             suggestions <- c(suggestions, sprintf("The 'rshcmd' (%s) used may not support reverse tunneling (revtunnel = TRUE). See ?future::makeClusterPSOCK for alternatives.\n", 
                 rshcmd_label))
         }
         if (length(suggestions) > 0) {
             suggestions <- sprintf("   - Suggestion #%d: %s\n", seq_along(suggestions), 
                 suggestions)
             msg <- c(msg, " * Troubleshooting suggestions:\n", suggestions)
         }
         msg <- paste(msg, collapse = "")
         ex$message <- msg
         local({
             oopts <- options(warning.length = 2000L)
             on.exit(options(oopts))
             stop(ex)
         })
     })
  13: tryCatchList(expr, classes, parentenv, handlers)
  14: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  15: value[[3L]](cond)
  16: (function() {
         oopts <- options(warning.length = 2000L)
         on.exit(options(oopts))
         stop(ex)
     })()
  
  -- 2. Error: Example 5(c). Setting: no noise in signal, all pattern occurences o
  Failed to launch and connect to R worker on local machine 'localhost' from local machine 'CRANWIN'.
   * The error produced by socketConnection() was: 'cannot open the connection'
   * In addition, socketConnection() produced 1 warning(s):
     - Warning #1: 'port 11748 cannot be opened' (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)
   * The localhost socket connection that failed to connect to the R worker used port 11748 using a communication timeout of 120 seconds and a connection timeout of 120 seconds.
   * Worker launch call: "D:/RCompile/recent/R-36~1.1/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=testthat.R:64416:CRANWIN:CRAN" -e "try(cat(Sys.getpid(),file=\"D:/temp/RtmpiQLJL5/future.parent=64416.fba018fd2bb6.pid\"), silent = TRUE)" -e "parallel:::.slaveRSOCK()" MASTER=localhost PORT=11748 OUT=/dev/null TIMEOUT=120 XDR=TRUE.
   * Worker (PID 117256) was successfully killed: TRUE
   * Troubleshooting suggestions:
     - Suggestion #1: Set 'verbose=TRUE' to see more details.
     - Suggestion #2: On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).
  1: segmentPattern(x = x, x.fs = 1, template = template, pattern.dur.seq = pattern.dur.seq, 
         similarity.measure = "cor", x.cut = TRUE, x.cut.vl = 6000, run.parallel = TRUE, 
         run.parallel.cores = availableCores(), compute.template.idx = TRUE) at testthat/test-segmentPattern.R:655
  2: plan(multiprocess, workers = run.parallel.cores)
  3: plan_set(newStack, skip = .skip, cleanup = .cleanup, init = .init)
  4: plan_init()
  5: evaluator(NA, label = "future-plan-test", globals = FALSE, lazy = FALSE)
  6: fun(expr = expr, envir = envir, substitute = FALSE, lazy = lazy, seed = seed, globals = globals, 
         workers = workers, gc = gc, earlySignal = earlySignal, label = label, ...)
  7: ClusterRegistry("start", workers = workers)
  8: makeCluster(workers, ...)
  9: makeClusterPSOCK(workers, ...)
  10: makeNode(workers[[ii]], port = port, ..., rank = ii, verbose = verbose)
  11: (function() {
         setTimeLimit(elapsed = connectTimeout)
         on.exit(setTimeLimit(elapsed = Inf))
         warnings <- list()
         tryCatch({
             withCallingHandlers({
                 socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, 
                     open = "a+b", timeout = timeout)
             }, warning = function(w) {
                 if (verbose) {
                     message(sprintf("%sDetected a warning from socketConnection(): %s", 
                       verbose_prefix, sQuote(conditionMessage(w))))
                 }
                 warnings <<- c(warnings, list(w))
             })
         }, error = function(ex) {
             setTimeLimit(elapsed = Inf)
             machineType <- if (localMachine) 
                 "local"
             else "remote"
             msg <- sprintf("Failed to launch and connect to R worker on %s machine %s from local machine %s.\n", 
                 machineType, sQuote(worker), sQuote(Sys.info()[["nodename"]]))
             cmsg <- conditionMessage(ex)
             if (grepl(gettext("reached elapsed time limit"), cmsg)) {
                 msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s (which suggests that the connection timeout of %.0f seconds (argument 'connectTimeout') kicked in)\n", 
                     sQuote(cmsg), connectTimeout))
             }
             else {
                 msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s\n", 
                     sQuote(cmsg)))
             }
             if (length(warnings) > 0) {
                 msg <- c(msg, sprintf(" * In addition, socketConnection() produced %d warning(s):\n", 
                     length(warnings)))
                 for (kk in seq_along(warnings)) {
                     cmsg <- conditionMessage(warnings[[kk]])
                     if (grepl("port [0-9]+ cannot be opened", cmsg)) {
                       msg <- c(msg, sprintf("   - Warning #%d: %s (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)\n", 
                         kk, sQuote(cmsg)))
                     }
                     else {
                       msg <- c(msg, sprintf("   - Warning #%d: %s\n", kk, sQuote(cmsg)))
                     }
                 }
             }
             msg <- c(msg, sprintf(" * The localhost socket connection that failed to connect to the R worker used port %d using a communication timeout of %.0f seconds and a connection timeout of %.0f seconds.\n", 
                 port, timeout, connectTimeout))
             msg <- c(msg, sprintf(" * Worker launch call: %s.\n", local_cmd))
             pid <- readWorkerPID(pidfile)
             if (!is.null(pid)) {
                 if (verbose) 
                     message(sprintf("Killing worker process (PID %d) if still alive", 
                       pid))
                 success <- pid_kill(pid)
                 if (verbose) 
                     message(sprintf("Worker (PID %d) was successfully killed: %s", pid, 
                       success))
                 msg <- c(msg, sprintf(" * Worker (PID %d) was successfully killed: %s\n", 
                     pid, success))
             }
             else if (localMachine) {
                 msg <- c(msg, sprintf(" * Failed to kill local worker because it's PID is could not be identified.\n"))
             }
             suggestions <- NULL
             if (!verbose) {
                 suggestions <- c(suggestions, "Set 'verbose=TRUE' to see more details.")
             }
             if (.Platform$OS.type == "windows") {
                 if (is_worker_output_visible) {
                     suggestions <- c(suggestions, "On Windows, to see output from worker, set 'outfile=NULL' and run R from a terminal (not a GUI).")
                 }
                 else {
                     suggestions <- c(suggestions, "On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).")
                 }
             }
             else {
                 if (!is_worker_output_visible) {
                     suggestions <- c(suggestions, "Set 'outfile=NULL' to see output from worker.")
                 }
             }
             if (is.character(rshlogfile)) {
                 smsg <- sprintf("Inspect the content of log file %s for %s.", sQuote(rshlogfile), 
                     sQuote(rshcmd))
                 lmsg <- tryCatch(readLines(rshlogfile, n = 15L, warn = FALSE), error = function(ex) NULL)
                 if (length(lmsg) > 0) {
                     lmsg <- sprintf("     %2d: %s", seq_along(lmsg), lmsg)
                     smsg <- sprintf("%s The first %d lines are:\n%s", smsg, length(lmsg), 
                       paste(lmsg, collapse = "\n"))
                 }
                 suggestions <- c(suggestions, smsg)
             }
             else {
                 suggestions <- c(suggestions, sprintf("Set 'rshlogfile=TRUE' to enable logging for %s.", 
                     sQuote(rshcmd)))
             }
             if (!localMachine && revtunnel && isTRUE(attr(rshcmd, "OpenSSH_for_Windows"))) {
                 suggestions <- c(suggestions, sprintf("The 'rshcmd' (%s) used may not support reverse tunneling (revtunnel = TRUE). See ?future::makeClusterPSOCK for alternatives.\n", 
                     rshcmd_label))
             }
             if (length(suggestions) > 0) {
                 suggestions <- sprintf("   - Suggestion #%d: %s\n", seq_along(suggestions), 
                     suggestions)
                 msg <- c(msg, " * Troubleshooting suggestions:\n", suggestions)
             }
             msg <- paste(msg, collapse = "")
             ex$message <- msg
             local({
                 oopts <- options(warning.length = 2000L)
                 on.exit(options(oopts))
                 stop(ex)
             })
         })
     })()
  12: tryCatch({
         withCallingHandlers({
             socketConnection("localhost", port = port, server = TRUE, blocking = TRUE, 
                 open = "a+b", timeout = timeout)
         }, warning = function(w) {
             if (verbose) {
                 message(sprintf("%sDetected a warning from socketConnection(): %s", verbose_prefix, 
                     sQuote(conditionMessage(w))))
             }
             warnings <<- c(warnings, list(w))
         })
     }, error = function(ex) {
         setTimeLimit(elapsed = Inf)
         machineType <- if (localMachine) 
             "local"
         else "remote"
         msg <- sprintf("Failed to launch and connect to R worker on %s machine %s from local machine %s.\n", 
             machineType, sQuote(worker), sQuote(Sys.info()[["nodename"]]))
         cmsg <- conditionMessage(ex)
         if (grepl(gettext("reached elapsed time limit"), cmsg)) {
             msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s (which suggests that the connection timeout of %.0f seconds (argument 'connectTimeout') kicked in)\n", 
                 sQuote(cmsg), connectTimeout))
         }
         else {
             msg <- c(msg, sprintf(" * The error produced by socketConnection() was: %s\n", 
                 sQuote(cmsg)))
         }
         if (length(warnings) > 0) {
             msg <- c(msg, sprintf(" * In addition, socketConnection() produced %d warning(s):\n", 
                 length(warnings)))
             for (kk in seq_along(warnings)) {
                 cmsg <- conditionMessage(warnings[[kk]])
                 if (grepl("port [0-9]+ cannot be opened", cmsg)) {
                     msg <- c(msg, sprintf("   - Warning #%d: %s (which suggests that this port is either already occupied by another process or blocked by the firewall on your local machine)\n", 
                       kk, sQuote(cmsg)))
                 }
                 else {
                     msg <- c(msg, sprintf("   - Warning #%d: %s\n", kk, sQuote(cmsg)))
                 }
             }
         }
         msg <- c(msg, sprintf(" * The localhost socket connection that failed to connect to the R worker used port %d using a communication timeout of %.0f seconds and a connection timeout of %.0f seconds.\n", 
             port, timeout, connectTimeout))
         msg <- c(msg, sprintf(" * Worker launch call: %s.\n", local_cmd))
         pid <- readWorkerPID(pidfile)
         if (!is.null(pid)) {
             if (verbose) 
                 message(sprintf("Killing worker process (PID %d) if still alive", pid))
             success <- pid_kill(pid)
             if (verbose) 
                 message(sprintf("Worker (PID %d) was successfully killed: %s", pid, success))
             msg <- c(msg, sprintf(" * Worker (PID %d) was successfully killed: %s\n", 
                 pid, success))
         }
         else if (localMachine) {
             msg <- c(msg, sprintf(" * Failed to kill local worker because it's PID is could not be identified.\n"))
         }
         suggestions <- NULL
         if (!verbose) {
             suggestions <- c(suggestions, "Set 'verbose=TRUE' to see more details.")
         }
         if (.Platform$OS.type == "windows") {
             if (is_worker_output_visible) {
                 suggestions <- c(suggestions, "On Windows, to see output from worker, set 'outfile=NULL' and run R from a terminal (not a GUI).")
             }
             else {
                 suggestions <- c(suggestions, "On Windows, output from worker when using 'outfile=NULL' is only visible when running R from a terminal (not a GUI).")
             }
         }
         else {
             if (!is_worker_output_visible) {
                 suggestions <- c(suggestions, "Set 'outfile=NULL' to see output from worker.")
             }
         }
         if (is.character(rshlogfile)) {
             smsg <- sprintf("Inspect the content of log file %s for %s.", sQuote(rshlogfile), 
                 sQuote(rshcmd))
             lmsg <- tryCatch(readLines(rshlogfile, n = 15L, warn = FALSE), error = function(ex) NULL)
             if (length(lmsg) > 0) {
                 lmsg <- sprintf("     %2d: %s", seq_along(lmsg), lmsg)
                 smsg <- sprintf("%s The first %d lines are:\n%s", smsg, length(lmsg), 
                     paste(lmsg, collapse = "\n"))
             }
             suggestions <- c(suggestions, smsg)
         }
         else {
             suggestions <- c(suggestions, sprintf("Set 'rshlogfile=TRUE' to enable logging for %s.", 
                 sQuote(rshcmd)))
         }
         if (!localMachine && revtunnel && isTRUE(attr(rshcmd, "OpenSSH_for_Windows"))) {
             suggestions <- c(suggestions, sprintf("The 'rshcmd' (%s) used may not support reverse tunneling (revtunnel = TRUE). See ?future::makeClusterPSOCK for alternatives.\n", 
                 rshcmd_label))
         }
         if (length(suggestions) > 0) {
             suggestions <- sprintf("   - Suggestion #%d: %s\n", seq_along(suggestions), 
                 suggestions)
             msg <- c(msg, " * Troubleshooting suggestions:\n", suggestions)
         }
         msg <- paste(msg, collapse = "")
         ex$message <- msg
         local({
             oopts <- options(warning.length = 2000L)
             on.exit(options(oopts))
             stop(ex)
         })
     })
  13: tryCatchList(expr, classes, parentenv, handlers)
  14: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  15: value[[3L]](cond)
  16: (function() {
         oopts <- options(warning.length = 2000L)
         on.exit(options(oopts))
         stop(ex)
     })()
  
  == testthat results  ===========================================================
  OK: 102 SKIPPED: 0 WARNINGS: 2 FAILED: 2
  1. Error: Example 5(a). Setting: no noise in signal, all pattern occurences of the same
            length, long signal. We check for the same behaviour with and without parallel
            computation with fixed number of 2 workers. (@test-segmentPattern.R#575) 
  2. Error: Example 5(c). Setting: no noise in signal, all pattern occurences of the same
            length, long signal. We check for the same behaviour with and without parallel
            computation with (maximum-1) number of workers available. (@test-segmentPattern.R#655) 
  
  Error: testthat unit tests failed
  Execution halted