Running ‘test-all.R’ [4s/19s]
Running the tests in ‘tests/test-all.R’ failed.
Complete output:
  > # FIXME: R CMD check does not run on true batch systems, but maybe it does not have to
  > # we can check there with 'make test' and run 'make check' locally
  > 
  > library(testthat)
  > test_check("parallelMap")
  Loading required package: parallelMap
  ── 1. Error: BatchJobs mode (@test_batchjobs.R#5)  ─────────────────────────────
  package or namespace load failed for 'BatchJobs':
   .onLoad failed in loadNamespace() for 'BatchJobs', details:
    call: qassert(null.ok, "B1")
    error: LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: library(BatchJobs) at testthat/test_batchjobs.R:5
  2: tryCatch({
         attr(package, "LibPath") <- which.lib.loc
         ns <- loadNamespace(package, lib.loc)
         env <- attachNamespace(ns, pos = pos, deps)
     }, error = function(e) {
         P <- if (!is.null(cc <- conditionCall(e))) 
             paste(" in", deparse(cc)[1L])
         else ""
         msg <- gettextf("package or namespace load failed for %s%s:\n %s", sQuote(package), 
             P, conditionMessage(e))
         if (logical.return) 
             message(paste("Error:", msg), domain = NA)
         else stop(msg, call. = FALSE, domain = NA)
     })
  3: tryCatchList(expr, classes, parentenv, handlers)
  4: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  5: value[[3L]](cond)
  6: stop(msg, call. = FALSE, domain = NA)
  
  ── 2. Error: local mode (@test_local.R#4)  ─────────────────────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: parallelStartLocal() at testthat/test_local.R:4
  2: parallelStart(mode = MODE_LOCAL, cpus = NA_integer_, level = NA_character_, logging = FALSE, 
         show.info = show.info, suppress.local.errors = suppress.local.errors)
  3: getPMDefOptMode(mode)
  4: assertChoice(mode, MODES)
  5: checkChoice(x, choices, null.ok, fmatch)
  6: qassert(null.ok, "B1")
  
  ── 3. Error: parallelLapply (@test_parallelApply.R#4)  ─────────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'symbol'
  1: parallelStart(mode = "local") at testthat/test_parallelApply.R:4
  2: getPMDefOptMode(mode)
  3: assertChoice(mode, MODES)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 4. Error: parallelSapply (@test_parallelApply.R#14)  ────────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'symbol'
  1: parallelStart(mode = "local") at testthat/test_parallelApply.R:14
  2: getPMDefOptMode(mode)
  3: assertChoice(mode, MODES)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 5. Error: get / print options (@test_parallelGetOptions.R#9)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: capture.output(print(parallelGetOptions())) at testthat/test_parallelGetOptions.R:9
  2: evalVis(expr)
  3: withVisible(eval(expr, pf))
  4: eval(expr, pf)
  5: eval(expr, pf)
  6: print(parallelGetOptions())
  7: print.ParallelMapOptions(parallelGetOptions())
  8: getPMDefOptMode()
  9: assertChoice(mode, MODES)
  10: checkChoice(x, choices, null.ok, fmatch)
  11: qassert(null.ok, "B1")
  
  
   *** caught segfault ***
  address 4d, cause 'memory not mapped'
  
  Traceback:
   1: qassert(null.ok, "B1")
   2: checkChoice(x, choices, null.ok, fmatch)
   3: assertChoice(mode, MODES)
   4: getPMDefOptMode(mode)
   5: parallelStart(mode = MODE_BATCHJOBS, level = level, logging = logging,     storagedir = storagedir, bj.resources = bj.resources, show.info = show.info)
   6: parallelStartBatchJobs(level = "foo")
   7: eval_bare(get_expr(quo), get_env(quo))
   8: withCallingHandlers(code, warning = function(condition) {    out$push(condition)    invokeRestart("muffleWarning")})
   9: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  10: quasi_capture(enquo(object), capture_warnings, label = label)
  11: expect_warning(parallelStartBatchJobs(level = "foo"), "not registered")
  12: eval(code, test_env)
  13: eval(code, test_env)
  14: withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error)
  15: doTryCatch(return(expr), name, parentenv, handler)
  16: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  17: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  18: doTryCatch(return(expr), name, parentenv, handler)
  19: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  20: tryCatchList(expr, classes, parentenv, handlers)
  21: tryCatch(withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error), error = handle_fatal,     skip = function(e) {    })
  22: test_code(desc, code, env = parent.frame())
  23: test_that("warn on unregisterred level", {    expect_warning(parallelStartBatchJobs(level = "foo"), "not registered")    parallelStop()    opt = getOption("warn")    options(warn = 2L)    parallelStartBatchJobs()    parallelStop()    options(warn = opt)})
  24: eval(code, test_env)
  25: eval(code, test_env)
  26: withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error)
  27: doTryCatch(return(expr), name, parentenv, handler)
  28: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  29: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  30: doTryCatch(return(expr), name, parentenv, handler)
  31: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  32: tryCatchList(expr, classes, parentenv, handlers)
  33: tryCatch(withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error), error = handle_fatal,     skip = function(e) {    })
  34: test_code(NULL, exprs, env)
  35: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  36: force(code)
  37: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,     {        lister$start_file(basename(path))        source_file(path, new.env(parent = env), chdir = TRUE,             wrap = wrap)        end_context()    })
  38: FUN(X[[i]], ...)
  39: lapply(paths, test_file, env = env, reporter = current_reporter,     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  40: force(code)
  41: with_reporter(reporter = current_reporter, results <- lapply(paths,     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,     load_helpers = FALSE, wrap = wrap))
  42: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,     stop_on_warning = stop_on_warning, wrap = wrap)
  43: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,     wrap = wrap)
  44: test_package_dir(package = package, test_path = test_path, filter = filter,     reporter = reporter, ..., stop_on_failure = stop_on_failure,     stop_on_warning = stop_on_warning, wrap = wrap)
  45: test_check("parallelMap")
  An irrecoverable exception occurred. R is aborting now ...