CRAN Package Check Results for Maintainer ‘Henrik Bengtsson <henrikb at braju.com>’

Last updated on 2020-02-15 01:02:01 CET.

Package ERROR NOTE OK
ACNE 13
aroma.affymetrix 8 5
aroma.apd 1 12
aroma.cn 2 11
aroma.core 13
calmate 13
dChipIO 13
doFuture 13
future 2 11
future.apply 13
future.BatchJobs 13
future.batchtools 13
future.callr 13
globals 13
listenv 13
matrixStats 8 5
profmem 13
progressr 2 11
PSCBS 13
R.cache 13
R.devices 1 12
R.filesets 13
R.huge 13
R.matlab 13
R.methodsS3 13
R.oo 13
R.rsp 2 11
R.utils 13
startup 2 11

Package ACNE

Current CRAN status: OK: 13

Package aroma.affymetrix

Current CRAN status: NOTE: 8, OK: 5

Version: 3.2.0
Check: installed package size
Result: NOTE
     installed size is 5.8Mb
     sub-directories of 1Mb or more:
     R 2.3Mb
     help 1.1Mb
     testScripts 1.3Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-solaris-x86, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘AffymetrixDataTestFiles’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package aroma.apd

Current CRAN status: NOTE: 1, OK: 12

Version: 0.6.0
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘affxparser’
Flavor: r-release-osx-x86_64

Version: 0.6.0
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘affxparser’
Flavor: r-release-osx-x86_64

Package aroma.cn

Current CRAN status: NOTE: 2, OK: 11

Version: 1.6.1
Check: package dependencies
Result: NOTE
    Package suggested but not available for checking: ‘GLAD’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package aroma.core

Current CRAN status: NOTE: 13

Version: 3.2.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-ix86+x86_64, r-patched-linux-x86_64, r-patched-solaris-x86, r-release-linux-x86_64, r-release-windows-ix86+x86_64

Version: 3.2.0
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavor: r-devel-windows-ix86+x86_64-gcc8

Version: 3.2.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'GLAD', 'sfit', 'expectile', 'HaarSeg', 'mpcbs'
Flavor: r-release-osx-x86_64

Version: 3.2.1
Check: Rd cross-references
Result: NOTE
    Package unavailable to check Rd xrefs: ‘GLAD’
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Version: 3.2.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     'sfit' 'expectile' 'HaarSeg' 'mpcbs'
Flavor: r-oldrel-windows-ix86+x86_64

Version: 3.2.1
Check: package dependencies
Result: NOTE
    Packages suggested but not available for checking:
     ‘GLAD’ ‘sfit’ ‘expectile’ ‘HaarSeg’ ‘mpcbs’
Flavor: r-oldrel-osx-x86_64

Package calmate

Current CRAN status: OK: 13

Package dChipIO

Current CRAN status: OK: 13

Package doFuture

Current CRAN status: OK: 13

Package future

Current CRAN status: ERROR: 2, OK: 11

Version: 1.16.0
Check: tests
Result: ERROR
     Running '000.sessionDetails.R' [7s/8s]
     Running 'ClusterRegistry.R' [3s/54s]
     Running 'Future-class.R' [2s/18s]
     Running 'FutureError.R' [1s/1s]
     Running 'FutureGlobals.R' [1s/1s]
     Running 'FutureRegistry.R' [1s/1s]
     Running 'as.cluster.R' [1s/19s]
     Running 'availableCores.R' [1s/1s]
     Running 'availableWorkers.R' [1s/1s]
     Running 'backtrace.R' [1s/2s]
     Running 'cluster-missing-future-pkg.R' [1s/3s]
     Running 'cluster.R' [7s/123s]
     Running 'constant.R' [1s/1s]
     Running 'demo.R' [10s/28s]
     Running 'dotdotdot.R' [2s/19s]
     Running 'early-signaling.R' [2s/41s]
     Running 'future,labels.R' [1s/1s]
     Running 'future.R' [1s/1s]
     Running 'futureAssign.R' [2s/20s]
     Running 'futureAssign_OP.R' [3s/21s]
     Running 'futureAssign_OP_with_environment.R' [1s/1s]
     Running 'futureAssign_OP_with_listenv.R' [1s/1s]
     Running 'futureCall.R' [4s/31s]
     Running 'futureOf.R' [1s/1s]
     Running 'futureOf_with_environment.R' [1s/1s]
     Running 'futureOf_with_listenv.R' [1s/1s]
     Running 'futures.R' [20s/151s]
     Running 'globals,NSE.R' [1s/1s]
     Running 'globals,formulas.R' [4s/23s]
     Running 'globals,manual.R' [2s/3s]
     Running 'globals,resolve.R' [2s/18s]
     Running 'globals,subassignment.R' [3s/23s]
     Running 'globals,toolarge.R' [1s/18s]
     Running 'globals,tricky.R' [8s/28s]
     Running 'globals,tricky_recursive.R' [1s/1s]
     Running 'globalsOf,tweaks.R' [1s/1s]
     Running 'immediateCondition.R' [1s/2s]
     Running 'invalid-owner.R' [2s/19s]
     Running 'makeClusterPSOCK.R' [1s/9s]
     Running 'mandelbrot.R' [1s/1s]
     Running 'mpi.R' [1s/1s]
     Running 'multicore,multithreading.R' [1s/1s]
     Running 'multicore.R' [1s/1s]
     Running 'multiprocess.R' [2s/2s]
     Running 'multisession.R' [4s/56s]
     Running 'nbrOfWorkers.R' [5s/72s]
     Running 'nested_futures,mc.cores.R' [6s/124s]
     Running 'nested_futures.R' [1s/1s]
     Running 'non-exportable,connections.R' [1s/19s]
     Running 'objectSize.R' [1s/1s]
     Running 'plan.R' [6s/16s]
     Running 'relaying.R' [1s/2s]
     Running 'remote.R' [1s/18s]
     Running 'requestCore.R' [1s/3s]
     Running 'requestNode.R' [2s/32s]
     Running 'reserved-keyword-functions.R' [1s/1s]
     Running 'resolve.R' [2s/4s]
     Running 'resolved-non-blocking-test.R' [3s/72s]
     Running 'rng.R' [12s/36s]
     Running 'sequential.R' [1s/1s]
     Running 'sessionDetails.R' [1s/1s]
     Running 'startup.R' [2s/36s]
     Running 'stdout.R' [2s/20s]
     Running 'transparent.R' [1s/1s]
     Running 'tweak.R' [1s/1s]
     Running 'utils.R' [8s/9s]
     Running 'uuid.R' [1s/1s]
     Running 'whichIndex.R' [1s/1s]
    Running the tests in 'tests/multicore,multithreading.R' failed.
    Complete output:
     > source("incl/start.R")
     [23:28:09.821] plan(): Setting new future strategy stack:
     [23:28:09.823] List of future strategies:
     [23:28:09.823] 1. sequential:
     [23:28:09.823] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:28:09.823] - tweaked: FALSE
     [23:28:09.823] - call: future::plan("sequential")
     [23:28:09.825] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [23:28:09.881] plan(): Setting new future strategy stack:
     [23:28:09.881] List of future strategies:
     [23:28:09.881] 1. multicore:
     [23:28:09.881] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:28:09.881] - tweaked: FALSE
     [23:28:09.881] - call: plan(multicore)
     [23:28:09.919] plan(): nbrOfWorkers() = 2
     >
     > message("*** multicore() and multi-threading ...")
     *** multicore() and multi-threading ...
     >
     > message("supportsMulticore(): ", sQuote(supportsMulticore()))
     supportsMulticore(): 'TRUE'
     > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
     availableCores('multicore'): '2'
     > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
     [23:28:10.064] supports_omp_threads() = TRUE
     supports_omp_threads(): 'TRUE'
     >
     > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
     + for (enable in c(TRUE, FALSE)) {
     + options(future.fork.multithreading.enable = enable)
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
     +
     + f <- future(RhpcBLASctl::omp_get_max_threads())
     + nthreads <- value(f)
     + cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
     +
     + ## Assert that single-threading was set?
     + if (enable) {
     + stopifnot(enable && nthreads > 1L)
     + } else {
     + stopifnot(!enable && nthreads == 1L)
     + }
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
     + } ## for (enable ...)
     + } ## if (requireNamespace("RhpcBLASctl", ...)) {
     [23:28:10.066] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [23:28:10.134] getGlobalsAndPackages() ...
     [23:28:10.134] Searching for globals...
     [23:28:10.160] - globals found: [1] '::'
     [23:28:10.161] Searching for globals ... DONE
     [23:28:10.161] Resolving globals: FALSE
     [23:28:10.163]
     [23:28:10.163]
     [23:28:10.164] getGlobalsAndPackages() ... DONE
     [23:28:10.169] Packages needed by the future expression (n = 0): <none>
     [23:28:10.170] Packages needed by future strategies (n = 0): <none>
     [23:28:10.210] {
     [23:28:10.210] {
     [23:28:10.210] ...future.startTime <- base::Sys.time()
     [23:28:10.210] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:28:10.210] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:28:10.210] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:28:10.210] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:28:10.210] future.resolve.recursive = NULL, width = 80L)
     [23:28:10.210] {
     [23:28:10.210] {
     [23:28:10.210] {
     [23:28:10.210] has_future <- base::requireNamespace("future",
     [23:28:10.210] quietly = TRUE)
     [23:28:10.210] version <- if (has_future)
     [23:28:10.210] utils::packageVersion("future")
     [23:28:10.210] else NULL
     [23:28:10.210] if (!has_future || version < "1.8.0") {
     [23:28:10.210] info <- base::c(r_version = base::gsub("R version ",
     [23:28:10.210] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:28:10.210] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:28:10.210] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:28:10.210] "release", "version")], collapse = " "),
     [23:28:10.210] hostname = base::Sys.info()[["nodename"]])
     [23:28:10.210] info <- base::sprintf("%s: %s", base::names(info),
     [23:28:10.210] info)
     [23:28:10.210] info <- base::paste(info, collapse = "; ")
     [23:28:10.210] if (!has_future) {
     [23:28:10.210] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:28:10.210] info)
     [23:28:10.210] }
     [23:28:10.210] else {
     [23:28:10.210] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:28:10.210] info, version)
     [23:28:10.210] }
     [23:28:10.210] base::stop(msg)
     [23:28:10.210] }
     [23:28:10.210] }
     [23:28:10.210] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:28:10.210] base::options(mc.cores = 1L)
     [23:28:10.210] }
     [23:28:10.210] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:28:10.210] }
     [23:28:10.210] }
     [23:28:10.210] if (base::is.na(TRUE)) {
     [23:28:10.210] }
     [23:28:10.210] else {
     [23:28:10.210] if (TRUE) {
     [23:28:10.210] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:28:10.210] open = "w")
     [23:28:10.210] }
     [23:28:10.210] else {
     [23:28:10.210] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:28:10.210] windows = "NUL", "/dev/null"), open = "w")
     [23:28:10.210] }
     [23:28:10.210] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:28:10.210] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:28:10.210] base::sink(type = "output", split = FALSE)
     [23:28:10.210] base::close(...future.stdout)
     [23:28:10.210] }, add = TRUE)
     [23:28:10.210] }
     [23:28:10.210] ...future.frame <- base::sys.nframe()
     [23:28:10.210] ...future.conditions <- base::list()
     [23:28:10.210] ...future.rng <- base::globalenv()$.Random.seed
     [23:28:10.210] ...future.result <- base::tryCatch({
     [23:28:10.210] base::withCallingHandlers({
     [23:28:10.210] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:28:10.210] future::FutureResult(value = ...future.value$value,
     [23:28:10.210] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:28:10.210] ...future.rng), started = ...future.startTime,
     [23:28:10.210] version = "1.8")
     [23:28:10.210] }, condition = base::local({
     [23:28:10.210] c <- base::c
     [23:28:10.210] inherits <- base::inherits
     [23:28:10.210] invokeRestart <- base::invokeRestart
     [23:28:10.210] length <- base::length
     [23:28:10.210] list <- base::list
     [23:28:10.210] seq.int <- base::seq.int
     [23:28:10.210] signalCondition <- base::signalCondition
     [23:28:10.210] sys.calls <- base::sys.calls
     [23:28:10.210] Sys.time <- base::Sys.time
     [23:28:10.210] `[[` <- base::`[[`
     [23:28:10.210] `+` <- base::`+`
     [23:28:10.210] `<<-` <- base::`<<-`
     [23:28:10.210] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:28:10.210] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:28:10.210] 3L)]
     [23:28:10.210] }
     [23:28:10.210] function(cond) {
     [23:28:10.210] if (inherits(cond, "error")) {
     [23:28:10.210] ...future.conditions[[length(...future.conditions) +
     [23:28:10.210] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:28:10.210] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:28:10.210] signalCondition(cond)
     [23:28:10.210] }
     [23:28:10.210] else if (inherits(cond, "condition")) {
     [23:28:10.210] signal <- FALSE && inherits(cond, character(0))
     [23:28:10.210] ...future.conditions[[length(...future.conditions) +
     [23:28:10.210] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:28:10.210] if (!signal) {
     [23:28:10.210] muffleCondition <- function (cond)
     [23:28:10.210] {
     [23:28:10.210] inherits <- base::inherits
     [23:28:10.210] invokeRestart <- base::invokeRestart
     [23:28:10.210] muffled <- FALSE
     [23:28:10.210] if (inherits(cond, "message")) {
     [23:28:10.210] invokeRestart("muffleMessage")
     [23:28:10.210] muffled <- TRUE
     [23:28:10.210] }
     [23:28:10.210] else if (inherits(cond, "warning")) {
     [23:28:10.210] invokeRestart("muffleWarning")
     [23:28:10.210] muffled <- TRUE
     [23:28:10.210] }
     [23:28:10.210] else if (inherits(cond, "condition")) {
     [23:28:10.210] computeRestarts <- base::computeRestarts
     [23:28:10.210] grepl <- base::grepl
     [23:28:10.210] is.null <- base::is.null
     [23:28:10.210] restarts <- computeRestarts(cond)
     [23:28:10.210] for (restart in restarts) {
     [23:28:10.210] name <- restart$name
     [23:28:10.210] if (is.null(name))
     [23:28:10.210] next
     [23:28:10.210] if (!grepl("^muffle", name))
     [23:28:10.210] next
     [23:28:10.210] invokeRestart(restart)
     [23:28:10.210] muffled <- TRUE
     [23:28:10.210] break
     [23:28:10.210] }
     [23:28:10.210] }
     [23:28:10.210] invisible(muffled)
     [23:28:10.210] }
     [23:28:10.210] muffleCondition(cond)
     [23:28:10.210] }
     [23:28:10.210] }
     [23:28:10.210] }
     [23:28:10.210] }))
     [23:28:10.210] }, error = function(ex) {
     [23:28:10.210] base::structure(base::list(value = NULL, visible = NULL,
     [23:28:10.210] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:28:10.210] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:28:10.210] }, finally = {
     [23:28:10.210] {
     [23:28:10.210] {
     [23:28:10.210] base::options(mc.cores = ...future.mc.cores.old)
     [23:28:10.210] }
     [23:28:10.210] future::plan(list(function (expr, envir = parent.frame(),
     [23:28:10.210] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:28:10.210] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:28:10.210] earlySignal = FALSE, label = NULL, ...)
     [23:28:10.210] {
     [23:28:10.210] if (substitute)
     [23:28:10.210] expr <- substitute(expr)
     [23:28:10.210] if (is.function(workers))
     [23:28:10.210] workers <- workers()
     [23:28:10.210] workers <- as.integer(workers)
     [23:28:10.210] stop_if_not(is.finite(workers), workers >= 1L)
     [23:28:10.210] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:28:10.210] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:28:10.210] lazy = lazy, seed = seed, globals = globals,
     [23:28:10.210] local = TRUE, label = label, ...))
     [23:28:10.210] }
     [23:28:10.210] oopts <- options(mc.cores = workers)
     [23:28:10.210] on.exit(options(oopts))
     [23:28:10.210] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:28:10.210] substitute = FALSE, lazy = lazy, seed = seed,
     [23:28:10.210] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:28:10.210] label = label, ...)
     [23:28:10.210] if (!future$lazy)
     [23:28:10.210] future <- run(future)
     [23:28:10.210] invisible(future)
     [23:28:10.210] }), .cleanup = FALSE, .init = FALSE)
     [23:28:10.210] }
     [23:28:10.210] base::options(...future.oldOptions)
     [23:28:10.210] })
     [23:28:10.210] Sys.time
     [23:28:10.210] if (base::is.na(TRUE)) {
     [23:28:10.210] }
     [23:28:10.210] else {
     [23:28:10.210] base::sink(type = "output", split = FALSE)
     [23:28:10.210] if (TRUE) {
     [23:28:10.210] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:28:10.210] }
     [23:28:10.210] else {
     [23:28:10.210] ...future.result["stdout"] <- base::list(NULL)
     [23:28:10.210] }
     [23:28:10.210] base::close(...future.stdout)
     [23:28:10.210] ...future.stdout <- NULL
     [23:28:10.210] }
     [23:28:10.210] ...future.result$conditions <- ...future.conditions
     [23:28:10.210] ...future.result
     [23:28:10.210] }
     [23:28:10.214] requestCore(): workers = 2
     [23:28:10.220] MulticoreFuture started
     [23:28:10.236] plan(): Setting new future strategy stack:
     [23:28:10.237] List of future strategies:
     [23:28:10.237] 1. sequential:
     [23:28:10.237] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:28:10.237] - tweaked: FALSE
     [23:28:10.237] - call: NULL
     [23:28:10.240] plan(): nbrOfWorkers() = 1
     [23:28:10.243] plan(): Setting new future strategy stack:
     [23:28:10.244] List of future strategies:
     [23:28:10.244] 1. multicore:
     [23:28:10.244] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:28:10.244] - tweaked: FALSE
     [23:28:10.244] - call: plan(multicore)
     [23:28:10.263] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [23:28:10.295] getGlobalsAndPackages() ...
     [23:28:10.296] Searching for globals...
     [23:28:10.298] - globals found: [1] '::'
     [23:28:10.299] Searching for globals ... DONE
     [23:28:10.299] Resolving globals: FALSE
     [23:28:10.300]
     [23:28:10.301]
     [23:28:10.301] getGlobalsAndPackages() ... DONE
     [23:28:10.302] - Evaluate future in single-threaded mode ...
     [23:28:10.302] supports_omp_threads() = TRUE
     [23:28:10.303] - Force single-threaded processing for OpenMP
     [23:28:10.303] - Evaluate future in single-threaded mode ... DONE
     [23:28:10.306] Packages needed by the future expression (n = 0): <none>
     [23:28:10.307] Packages needed by future strategies (n = 0): <none>
     [23:28:10.330] {
     [23:28:10.330] {
     [23:28:10.330] ...future.startTime <- base::Sys.time()
     [23:28:10.330] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [23:28:10.330] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [23:28:10.330] future.globals.method = NULL, future.globals.onMissing = NULL,
     [23:28:10.330] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [23:28:10.330] future.resolve.recursive = NULL, width = 80L)
     [23:28:10.330] {
     [23:28:10.330] {
     [23:28:10.330] {
     [23:28:10.330] has_future <- base::requireNamespace("future",
     [23:28:10.330] quietly = TRUE)
     [23:28:10.330] version <- if (has_future)
     [23:28:10.330] utils::packageVersion("future")
     [23:28:10.330] else NULL
     [23:28:10.330] if (!has_future || version < "1.8.0") {
     [23:28:10.330] info <- base::c(r_version = base::gsub("R version ",
     [23:28:10.330] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [23:28:10.330] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [23:28:10.330] os = base::paste(base::Sys.info()[base::c("sysname",
     [23:28:10.330] "release", "version")], collapse = " "),
     [23:28:10.330] hostname = base::Sys.info()[["nodename"]])
     [23:28:10.330] info <- base::sprintf("%s: %s", base::names(info),
     [23:28:10.330] info)
     [23:28:10.330] info <- base::paste(info, collapse = "; ")
     [23:28:10.330] if (!has_future) {
     [23:28:10.330] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [23:28:10.330] info)
     [23:28:10.330] }
     [23:28:10.330] else {
     [23:28:10.330] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [23:28:10.330] info, version)
     [23:28:10.330] }
     [23:28:10.330] base::stop(msg)
     [23:28:10.330] }
     [23:28:10.330] }
     [23:28:10.330] ...future.mc.cores.old <- base::getOption("mc.cores")
     [23:28:10.330] base::options(mc.cores = 1L)
     [23:28:10.330] }
     [23:28:10.330] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [23:28:10.330] }
     [23:28:10.330] }
     [23:28:10.330] if (base::is.na(TRUE)) {
     [23:28:10.330] }
     [23:28:10.330] else {
     [23:28:10.330] if (TRUE) {
     [23:28:10.330] ...future.stdout <- base::rawConnection(base::raw(0L),
     [23:28:10.330] open = "w")
     [23:28:10.330] }
     [23:28:10.330] else {
     [23:28:10.330] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [23:28:10.330] windows = "NUL", "/dev/null"), open = "w")
     [23:28:10.330] }
     [23:28:10.330] base::sink(...future.stdout, type = "output", split = FALSE)
     [23:28:10.330] base::on.exit(if (!base::is.null(...future.stdout)) {
     [23:28:10.330] base::sink(type = "output", split = FALSE)
     [23:28:10.330] base::close(...future.stdout)
     [23:28:10.330] }, add = TRUE)
     [23:28:10.330] }
     [23:28:10.330] ...future.frame <- base::sys.nframe()
     [23:28:10.330] ...future.conditions <- base::list()
     [23:28:10.330] ...future.rng <- base::globalenv()$.Random.seed
     [23:28:10.330] ...future.result <- base::tryCatch({
     [23:28:10.330] base::withCallingHandlers({
     [23:28:10.330] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [23:28:10.330] future::FutureResult(value = ...future.value$value,
     [23:28:10.330] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [23:28:10.330] ...future.rng), started = ...future.startTime,
     [23:28:10.330] version = "1.8")
     [23:28:10.330] }, condition = base::local({
     [23:28:10.330] c <- base::c
     [23:28:10.330] inherits <- base::inherits
     [23:28:10.330] invokeRestart <- base::invokeRestart
     [23:28:10.330] length <- base::length
     [23:28:10.330] list <- base::list
     [23:28:10.330] seq.int <- base::seq.int
     [23:28:10.330] signalCondition <- base::signalCondition
     [23:28:10.330] sys.calls <- base::sys.calls
     [23:28:10.330] Sys.time <- base::Sys.time
     [23:28:10.330] `[[` <- base::`[[`
     [23:28:10.330] `+` <- base::`+`
     [23:28:10.330] `<<-` <- base::`<<-`
     [23:28:10.330] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [23:28:10.330] calls[seq.int(from = from + 12L, to = length(calls) -
     [23:28:10.330] 3L)]
     [23:28:10.330] }
     [23:28:10.330] function(cond) {
     [23:28:10.330] if (inherits(cond, "error")) {
     [23:28:10.330] ...future.conditions[[length(...future.conditions) +
     [23:28:10.330] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [23:28:10.330] cond$call), timestamp = Sys.time(), signaled = 0L)
     [23:28:10.330] signalCondition(cond)
     [23:28:10.330] }
     [23:28:10.330] else if (inherits(cond, "condition")) {
     [23:28:10.330] signal <- FALSE && inherits(cond, character(0))
     [23:28:10.330] ...future.conditions[[length(...future.conditions) +
     [23:28:10.330] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [23:28:10.330] if (!signal) {
     [23:28:10.330] muffleCondition <- function (cond)
     [23:28:10.330] {
     [23:28:10.330] inherits <- base::inherits
     [23:28:10.330] invokeRestart <- base::invokeRestart
     [23:28:10.330] muffled <- FALSE
     [23:28:10.330] if (inherits(cond, "message")) {
     [23:28:10.330] invokeRestart("muffleMessage")
     [23:28:10.330] muffled <- TRUE
     [23:28:10.330] }
     [23:28:10.330] else if (inherits(cond, "warning")) {
     [23:28:10.330] invokeRestart("muffleWarning")
     [23:28:10.330] muffled <- TRUE
     [23:28:10.330] }
     [23:28:10.330] else if (inherits(cond, "condition")) {
     [23:28:10.330] computeRestarts <- base::computeRestarts
     [23:28:10.330] grepl <- base::grepl
     [23:28:10.330] is.null <- base::is.null
     [23:28:10.330] restarts <- computeRestarts(cond)
     [23:28:10.330] for (restart in restarts) {
     [23:28:10.330] name <- restart$name
     [23:28:10.330] if (is.null(name))
     [23:28:10.330] next
     [23:28:10.330] if (!grepl("^muffle", name))
     [23:28:10.330] next
     [23:28:10.330] invokeRestart(restart)
     [23:28:10.330] muffled <- TRUE
     [23:28:10.330] break
     [23:28:10.330] }
     [23:28:10.330] }
     [23:28:10.330] invisible(muffled)
     [23:28:10.330] }
     [23:28:10.330] muffleCondition(cond)
     [23:28:10.330] }
     [23:28:10.330] }
     [23:28:10.330] }
     [23:28:10.330] }))
     [23:28:10.330] }, error = function(ex) {
     [23:28:10.330] base::structure(base::list(value = NULL, visible = NULL,
     [23:28:10.330] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [23:28:10.330] ...future.rng), version = "1.8"), class = "FutureResult")
     [23:28:10.330] }, finally = {
     [23:28:10.330] {
     [23:28:10.330] {
     [23:28:10.330] base::options(mc.cores = ...future.mc.cores.old)
     [23:28:10.330] }
     [23:28:10.330] future::plan(list(function (expr, envir = parent.frame(),
     [23:28:10.330] substitute = TRUE, lazy = FALSE, seed = NULL,
     [23:28:10.330] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [23:28:10.330] earlySignal = FALSE, label = NULL, ...)
     [23:28:10.330] {
     [23:28:10.330] if (substitute)
     [23:28:10.330] expr <- substitute(expr)
     [23:28:10.330] if (is.function(workers))
     [23:28:10.330] workers <- workers()
     [23:28:10.330] workers <- as.integer(workers)
     [23:28:10.330] stop_if_not(is.finite(workers), workers >= 1L)
     [23:28:10.330] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [23:28:10.330] return(sequential(expr, envir = envir, substitute = FALSE,
     [23:28:10.330] lazy = lazy, seed = seed, globals = globals,
     [23:28:10.330] local = TRUE, label = label, ...))
     [23:28:10.330] }
     [23:28:10.330] oopts <- options(mc.cores = workers)
     [23:28:10.330] on.exit(options(oopts))
     [23:28:10.330] future <- MulticoreFuture(expr = expr, envir = envir,
     [23:28:10.330] substitute = FALSE, lazy = lazy, seed = seed,
     [23:28:10.330] globals = globals, workers = workers, earlySignal = earlySignal,
     [23:28:10.330] label = label, ...)
     [23:28:10.330] if (!future$lazy)
     [23:28:10.330] future <- run(future)
     [23:28:10.330] invisible(future)
     [23:28:10.330] }), .cleanup = FALSE, .init = FALSE)
     [23:28:10.330] }
     [23:28:10.330] base::options(...future.oldOptions)
     [23:28:10.330] })
     [23:28:10.330] Sys.time
     [23:28:10.330] if (base::is.na(TRUE)) {
     [23:28:10.330] }
     [23:28:10.330] else {
     [23:28:10.330] base::sink(type = "output", split = FALSE)
     [23:28:10.330] if (TRUE) {
     [23:28:10.330] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [23:28:10.330] }
     [23:28:10.330] else {
     [23:28:10.330] ...future.result["stdout"] <- base::list(NULL)
     [23:28:10.330] }
     [23:28:10.330] base::close(...future.stdout)
     [23:28:10.330] ...future.stdout <- NULL
     [23:28:10.330] }
     [23:28:10.330] ...future.result$conditions <- ...future.conditions
     [23:28:10.330] ...future.result
     [23:28:10.330] }
     [23:28:10.333] requestCore(): workers = 2
     [23:28:10.338] MulticoreFuture started
     [23:28:10.351] plan(): Setting new future strategy stack:
     [23:28:10.351] List of future strategies:
     [23:28:10.351] 1. sequential:
     [23:28:10.351] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [23:28:10.351] - tweaked: FALSE
     [23:28:10.351] - call: NULL
     [23:28:10.353] plan(): nbrOfWorkers() = 1
     [23:28:10.374] plan(): Setting new future strategy stack:
     [23:28:10.374] List of future strategies:
     [23:28:10.374] 1. multicore:
     [23:28:10.374] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [23:28:10.374] - tweaked: FALSE
     [23:28:10.374] - call: plan(multicore)
     [23:28:10.376] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 3
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.16.0
Check: tests
Result: ERROR
     Running ‘000.sessionDetails.R’
     Running ‘ClusterRegistry.R’ [2s/33s]
     Running ‘Future-class.R’ [1s/11s]
     Running ‘FutureError.R’
     Running ‘FutureGlobals.R’
     Running ‘FutureRegistry.R’
     Running ‘as.cluster.R’ [1s/10s]
     Running ‘availableCores.R’
     Running ‘availableWorkers.R’
     Running ‘backtrace.R’
     Running ‘cluster-missing-future-pkg.R’
     Running ‘cluster.R’ [5s/66s]
     Running ‘constant.R’
     Running ‘demo.R’ [6s/15s]
     Running ‘dotdotdot.R’ [1s/11s]
     Running ‘early-signaling.R’ [2s/24s]
     Running ‘future,labels.R’
     Running ‘future.R’
     Running ‘futureAssign.R’ [2s/11s]
     Running ‘futureAssign_OP.R’ [2s/12s]
     Running ‘futureAssign_OP_with_environment.R’
     Running ‘futureAssign_OP_with_listenv.R’
     Running ‘futureCall.R’ [3s/17s]
     Running ‘futureOf.R’
     Running ‘futureOf_with_environment.R’
     Running ‘futureOf_with_listenv.R’
     Running ‘futures.R’ [13s/84s]
     Running ‘globals,NSE.R’
     Running ‘globals,formulas.R’ [3s/13s]
     Running ‘globals,manual.R’
     Running ‘globals,resolve.R’ [1s/10s]
     Running ‘globals,subassignment.R’ [2s/12s]
     Running ‘globals,toolarge.R’ [1s/10s]
     Running ‘globals,tricky.R’ [5s/15s]
     Running ‘globals,tricky_recursive.R’
     Running ‘globalsOf,tweaks.R’
     Running ‘immediateCondition.R’
     Running ‘invalid-owner.R’ [1s/11s]
     Running ‘makeClusterPSOCK.R’
     Running ‘mandelbrot.R’
     Running ‘mpi.R’
     Running ‘multicore,multithreading.R’
     Running ‘multicore.R’
     Running ‘multiprocess.R’
     Running ‘multisession.R’ [3s/32s]
     Running ‘nbrOfWorkers.R’ [4s/40s]
     Running ‘nested_futures,mc.cores.R’ [4s/71s]
     Running ‘nested_futures.R’
     Running ‘non-exportable,connections.R’ [1s/10s]
     Running ‘objectSize.R’
     Running ‘plan.R’
     Running ‘relaying.R’
     Running ‘remote.R’ [1s/10s]
     Running ‘requestCore.R’
     Running ‘requestNode.R’ [1s/20s]
     Running ‘reserved-keyword-functions.R’
     Running ‘resolve.R’
     Running ‘resolved-non-blocking-test.R’ [2s/50s]
     Running ‘rng.R’ [8s/19s]
     Running ‘sequential.R’
     Running ‘sessionDetails.R’
     Running ‘startup.R’ [2s/20s]
     Running ‘stdout.R’ [2s/11s]
     Running ‘transparent.R’
     Running ‘tweak.R’
     Running ‘utils.R’
     Running ‘uuid.R’
     Running ‘whichIndex.R’
    Running the tests in ‘tests/multicore,multithreading.R’ failed.
    Complete output:
     > source("incl/start.R")
     [16:16:18.514] plan(): Setting new future strategy stack:
     [16:16:18.515] List of future strategies:
     [16:16:18.515] 1. sequential:
     [16:16:18.515] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:16:18.515] - tweaked: FALSE
     [16:16:18.515] - call: future::plan("sequential")
     [16:16:18.517] plan(): nbrOfWorkers() = 1
     > library("listenv")
     > plan(multicore)
     [16:16:18.537] plan(): Setting new future strategy stack:
     [16:16:18.537] List of future strategies:
     [16:16:18.537] 1. multicore:
     [16:16:18.537] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:16:18.537] - tweaked: FALSE
     [16:16:18.537] - call: plan(multicore)
     [16:16:18.559] plan(): nbrOfWorkers() = 2
     >
     > message("*** multicore() and multi-threading ...")
     *** multicore() and multi-threading ...
     >
     > message("supportsMulticore(): ", sQuote(supportsMulticore()))
     supportsMulticore(): 'TRUE'
     > message("availableCores('multicore'): ", sQuote(availableCores("multicore")))
     availableCores('multicore'): '2'
     > message("supports_omp_threads(): ", sQuote(supports_omp_threads()))
     [16:16:18.571] supports_omp_threads() = TRUE
     supports_omp_threads(): 'TRUE'
     >
     > if (supportsMulticore() && availableCores("multicore") >=2 && supports_omp_threads()) {
     + for (enable in c(TRUE, FALSE)) {
     + options(future.fork.multithreading.enable = enable)
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ...", enable))
     +
     + f <- future(RhpcBLASctl::omp_get_max_threads())
     + nthreads <- value(f)
     + cat(sprintf("Number of OpenMP threads in %s future: %d\n", sQuote(class(f)[1]), nthreads))
     +
     + ## Assert that single-threading was set?
     + if (enable) {
     + stopifnot(enable && nthreads > 1L)
     + } else {
     + stopifnot(!enable && nthreads == 1L)
     + }
     +
     + message(sprintf("'future.fork.multithreading.enable' = %s ... DONE", enable))
     + } ## for (enable ...)
     + } ## if (requireNamespace("RhpcBLASctl", ...)) {
     [16:16:18.574] supports_omp_threads() = TRUE
     'future.fork.multithreading.enable' = TRUE ...
     [16:16:18.593] getGlobalsAndPackages() ...
     [16:16:18.593] Searching for globals...
     [16:16:18.599] - globals found: [1] '::'
     [16:16:18.599] Searching for globals ... DONE
     [16:16:18.600] Resolving globals: FALSE
     [16:16:18.600]
     [16:16:18.601]
     [16:16:18.601] getGlobalsAndPackages() ... DONE
     [16:16:18.603] Packages needed by the future expression (n = 0): <none>
     [16:16:18.604] Packages needed by future strategies (n = 0): <none>
     [16:16:18.607] {
     [16:16:18.607] {
     [16:16:18.607] ...future.startTime <- base::Sys.time()
     [16:16:18.607] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:16:18.607] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:16:18.607] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:16:18.607] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:16:18.607] future.resolve.recursive = NULL, width = 80L)
     [16:16:18.607] {
     [16:16:18.607] {
     [16:16:18.607] {
     [16:16:18.607] has_future <- base::requireNamespace("future",
     [16:16:18.607] quietly = TRUE)
     [16:16:18.607] version <- if (has_future)
     [16:16:18.607] utils::packageVersion("future")
     [16:16:18.607] else NULL
     [16:16:18.607] if (!has_future || version < "1.8.0") {
     [16:16:18.607] info <- base::c(r_version = base::gsub("R version ",
     [16:16:18.607] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:16:18.607] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:16:18.607] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:16:18.607] "release", "version")], collapse = " "),
     [16:16:18.607] hostname = base::Sys.info()[["nodename"]])
     [16:16:18.607] info <- base::sprintf("%s: %s", base::names(info),
     [16:16:18.607] info)
     [16:16:18.607] info <- base::paste(info, collapse = "; ")
     [16:16:18.607] if (!has_future) {
     [16:16:18.607] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:16:18.607] info)
     [16:16:18.607] }
     [16:16:18.607] else {
     [16:16:18.607] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:16:18.607] info, version)
     [16:16:18.607] }
     [16:16:18.607] base::stop(msg)
     [16:16:18.607] }
     [16:16:18.607] }
     [16:16:18.607] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:16:18.607] base::options(mc.cores = 1L)
     [16:16:18.607] }
     [16:16:18.607] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:16:18.607] }
     [16:16:18.607] }
     [16:16:18.607] if (base::is.na(TRUE)) {
     [16:16:18.607] }
     [16:16:18.607] else {
     [16:16:18.607] if (TRUE) {
     [16:16:18.607] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:16:18.607] open = "w")
     [16:16:18.607] }
     [16:16:18.607] else {
     [16:16:18.607] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:16:18.607] windows = "NUL", "/dev/null"), open = "w")
     [16:16:18.607] }
     [16:16:18.607] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:16:18.607] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:16:18.607] base::sink(type = "output", split = FALSE)
     [16:16:18.607] base::close(...future.stdout)
     [16:16:18.607] }, add = TRUE)
     [16:16:18.607] }
     [16:16:18.607] ...future.frame <- base::sys.nframe()
     [16:16:18.607] ...future.conditions <- base::list()
     [16:16:18.607] ...future.rng <- base::globalenv()$.Random.seed
     [16:16:18.607] ...future.result <- base::tryCatch({
     [16:16:18.607] base::withCallingHandlers({
     [16:16:18.607] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:16:18.607] future::FutureResult(value = ...future.value$value,
     [16:16:18.607] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:16:18.607] ...future.rng), started = ...future.startTime,
     [16:16:18.607] version = "1.8")
     [16:16:18.607] }, condition = base::local({
     [16:16:18.607] c <- base::c
     [16:16:18.607] inherits <- base::inherits
     [16:16:18.607] invokeRestart <- base::invokeRestart
     [16:16:18.607] length <- base::length
     [16:16:18.607] list <- base::list
     [16:16:18.607] seq.int <- base::seq.int
     [16:16:18.607] signalCondition <- base::signalCondition
     [16:16:18.607] sys.calls <- base::sys.calls
     [16:16:18.607] Sys.time <- base::Sys.time
     [16:16:18.607] `[[` <- base::`[[`
     [16:16:18.607] `+` <- base::`+`
     [16:16:18.607] `<<-` <- base::`<<-`
     [16:16:18.607] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:16:18.607] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:16:18.607] 3L)]
     [16:16:18.607] }
     [16:16:18.607] function(cond) {
     [16:16:18.607] if (inherits(cond, "error")) {
     [16:16:18.607] ...future.conditions[[length(...future.conditions) +
     [16:16:18.607] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:16:18.607] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:16:18.607] signalCondition(cond)
     [16:16:18.607] }
     [16:16:18.607] else if (inherits(cond, "condition")) {
     [16:16:18.607] signal <- FALSE && inherits(cond, character(0))
     [16:16:18.607] ...future.conditions[[length(...future.conditions) +
     [16:16:18.607] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:16:18.607] if (!signal) {
     [16:16:18.607] muffleCondition <- function (cond)
     [16:16:18.607] {
     [16:16:18.607] inherits <- base::inherits
     [16:16:18.607] invokeRestart <- base::invokeRestart
     [16:16:18.607] muffled <- FALSE
     [16:16:18.607] if (inherits(cond, "message")) {
     [16:16:18.607] invokeRestart("muffleMessage")
     [16:16:18.607] muffled <- TRUE
     [16:16:18.607] }
     [16:16:18.607] else if (inherits(cond, "warning")) {
     [16:16:18.607] invokeRestart("muffleWarning")
     [16:16:18.607] muffled <- TRUE
     [16:16:18.607] }
     [16:16:18.607] else if (inherits(cond, "condition")) {
     [16:16:18.607] computeRestarts <- base::computeRestarts
     [16:16:18.607] grepl <- base::grepl
     [16:16:18.607] is.null <- base::is.null
     [16:16:18.607] restarts <- computeRestarts(cond)
     [16:16:18.607] for (restart in restarts) {
     [16:16:18.607] name <- restart$name
     [16:16:18.607] if (is.null(name))
     [16:16:18.607] next
     [16:16:18.607] if (!grepl("^muffle", name))
     [16:16:18.607] next
     [16:16:18.607] invokeRestart(restart)
     [16:16:18.607] muffled <- TRUE
     [16:16:18.607] break
     [16:16:18.607] }
     [16:16:18.607] }
     [16:16:18.607] invisible(muffled)
     [16:16:18.607] }
     [16:16:18.607] muffleCondition(cond)
     [16:16:18.607] }
     [16:16:18.607] }
     [16:16:18.607] }
     [16:16:18.607] }))
     [16:16:18.607] }, error = function(ex) {
     [16:16:18.607] base::structure(base::list(value = NULL, visible = NULL,
     [16:16:18.607] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:16:18.607] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:16:18.607] }, finally = {
     [16:16:18.607] {
     [16:16:18.607] {
     [16:16:18.607] base::options(mc.cores = ...future.mc.cores.old)
     [16:16:18.607] }
     [16:16:18.607] future::plan(list(function (expr, envir = parent.frame(),
     [16:16:18.607] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:16:18.607] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:16:18.607] earlySignal = FALSE, label = NULL, ...)
     [16:16:18.607] {
     [16:16:18.607] if (substitute)
     [16:16:18.607] expr <- substitute(expr)
     [16:16:18.607] if (is.function(workers))
     [16:16:18.607] workers <- workers()
     [16:16:18.607] workers <- as.integer(workers)
     [16:16:18.607] stop_if_not(is.finite(workers), workers >= 1L)
     [16:16:18.607] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:16:18.607] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:16:18.607] lazy = lazy, seed = seed, globals = globals,
     [16:16:18.607] local = TRUE, label = label, ...))
     [16:16:18.607] }
     [16:16:18.607] oopts <- options(mc.cores = workers)
     [16:16:18.607] on.exit(options(oopts))
     [16:16:18.607] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:16:18.607] substitute = FALSE, lazy = lazy, seed = seed,
     [16:16:18.607] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:16:18.607] label = label, ...)
     [16:16:18.607] if (!future$lazy)
     [16:16:18.607] future <- run(future)
     [16:16:18.607] invisible(future)
     [16:16:18.607] }), .cleanup = FALSE, .init = FALSE)
     [16:16:18.607] }
     [16:16:18.607] base::options(...future.oldOptions)
     [16:16:18.607] })
     [16:16:18.607] Sys.time
     [16:16:18.607] if (base::is.na(TRUE)) {
     [16:16:18.607] }
     [16:16:18.607] else {
     [16:16:18.607] base::sink(type = "output", split = FALSE)
     [16:16:18.607] if (TRUE) {
     [16:16:18.607] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:16:18.607] }
     [16:16:18.607] else {
     [16:16:18.607] ...future.result["stdout"] <- base::list(NULL)
     [16:16:18.607] }
     [16:16:18.607] base::close(...future.stdout)
     [16:16:18.607] ...future.stdout <- NULL
     [16:16:18.607] }
     [16:16:18.607] ...future.result$conditions <- ...future.conditions
     [16:16:18.607] ...future.result
     [16:16:18.607] }
     [16:16:18.610] requestCore(): workers = 2
     [16:16:18.614] MulticoreFuture started
     [16:16:18.617] plan(): Setting new future strategy stack:
     [16:16:18.617] List of future strategies:
     [16:16:18.617] 1. sequential:
     [16:16:18.617] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:16:18.617] - tweaked: FALSE
     [16:16:18.617] - call: NULL
     [16:16:18.618] plan(): nbrOfWorkers() = 1
     [16:16:18.622] plan(): Setting new future strategy stack:
     [16:16:18.622] List of future strategies:
     [16:16:18.622] 1. multicore:
     [16:16:18.622] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:16:18.622] - tweaked: FALSE
     [16:16:18.622] - call: plan(multicore)
     [16:16:18.624] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     'future.fork.multithreading.enable' = TRUE ... DONE
     'future.fork.multithreading.enable' = FALSE ...
     [16:16:18.633] getGlobalsAndPackages() ...
     [16:16:18.633] Searching for globals...
     [16:16:18.635] - globals found: [1] '::'
     [16:16:18.635] Searching for globals ... DONE
     [16:16:18.635] Resolving globals: FALSE
     [16:16:18.636]
     [16:16:18.636]
     [16:16:18.637] getGlobalsAndPackages() ... DONE
     [16:16:18.637] - Evaluate future in single-threaded mode ...
     [16:16:18.637] supports_omp_threads() = TRUE
     [16:16:18.638] - Force single-threaded processing for OpenMP
     [16:16:18.638] - Evaluate future in single-threaded mode ... DONE
     [16:16:18.639] Packages needed by the future expression (n = 0): <none>
     [16:16:18.639] Packages needed by future strategies (n = 0): <none>
     [16:16:18.643] {
     [16:16:18.643] {
     [16:16:18.643] ...future.startTime <- base::Sys.time()
     [16:16:18.643] ...future.oldOptions <- base::options(future.startup.script = FALSE,
     [16:16:18.643] future.globals.onMissing = "ignore", future.globals.maxSize = NULL,
     [16:16:18.643] future.globals.method = NULL, future.globals.onMissing = NULL,
     [16:16:18.643] future.globals.onReference = NULL, future.globals.resolve = NULL,
     [16:16:18.643] future.resolve.recursive = NULL, width = 80L)
     [16:16:18.643] {
     [16:16:18.643] {
     [16:16:18.643] {
     [16:16:18.643] has_future <- base::requireNamespace("future",
     [16:16:18.643] quietly = TRUE)
     [16:16:18.643] version <- if (has_future)
     [16:16:18.643] utils::packageVersion("future")
     [16:16:18.643] else NULL
     [16:16:18.643] if (!has_future || version < "1.8.0") {
     [16:16:18.643] info <- base::c(r_version = base::gsub("R version ",
     [16:16:18.643] "", base::R.version$version.string), platform = base::sprintf("%s (%s-bit)",
     [16:16:18.643] base::R.version$platform, 8 * base::.Machine$sizeof.pointer),
     [16:16:18.643] os = base::paste(base::Sys.info()[base::c("sysname",
     [16:16:18.643] "release", "version")], collapse = " "),
     [16:16:18.643] hostname = base::Sys.info()[["nodename"]])
     [16:16:18.643] info <- base::sprintf("%s: %s", base::names(info),
     [16:16:18.643] info)
     [16:16:18.643] info <- base::paste(info, collapse = "; ")
     [16:16:18.643] if (!has_future) {
     [16:16:18.643] msg <- base::sprintf("Package 'future' is not installed on worker (%s)",
     [16:16:18.643] info)
     [16:16:18.643] }
     [16:16:18.643] else {
     [16:16:18.643] msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s",
     [16:16:18.643] info, version)
     [16:16:18.643] }
     [16:16:18.643] base::stop(msg)
     [16:16:18.643] }
     [16:16:18.643] }
     [16:16:18.643] ...future.mc.cores.old <- base::getOption("mc.cores")
     [16:16:18.643] base::options(mc.cores = 1L)
     [16:16:18.643] }
     [16:16:18.643] future::plan("default", .cleanup = FALSE, .init = FALSE)
     [16:16:18.643] }
     [16:16:18.643] }
     [16:16:18.643] if (base::is.na(TRUE)) {
     [16:16:18.643] }
     [16:16:18.643] else {
     [16:16:18.643] if (TRUE) {
     [16:16:18.643] ...future.stdout <- base::rawConnection(base::raw(0L),
     [16:16:18.643] open = "w")
     [16:16:18.643] }
     [16:16:18.643] else {
     [16:16:18.643] ...future.stdout <- base::file(base::switch(.Platform$OS.type,
     [16:16:18.643] windows = "NUL", "/dev/null"), open = "w")
     [16:16:18.643] }
     [16:16:18.643] base::sink(...future.stdout, type = "output", split = FALSE)
     [16:16:18.643] base::on.exit(if (!base::is.null(...future.stdout)) {
     [16:16:18.643] base::sink(type = "output", split = FALSE)
     [16:16:18.643] base::close(...future.stdout)
     [16:16:18.643] }, add = TRUE)
     [16:16:18.643] }
     [16:16:18.643] ...future.frame <- base::sys.nframe()
     [16:16:18.643] ...future.conditions <- base::list()
     [16:16:18.643] ...future.rng <- base::globalenv()$.Random.seed
     [16:16:18.643] ...future.result <- base::tryCatch({
     [16:16:18.643] base::withCallingHandlers({
     [16:16:18.643] ...future.value <- base::withVisible(base::local(RhpcBLASctl::omp_get_max_threads()))
     [16:16:18.643] future::FutureResult(value = ...future.value$value,
     [16:16:18.643] visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed,
     [16:16:18.643] ...future.rng), started = ...future.startTime,
     [16:16:18.643] version = "1.8")
     [16:16:18.643] }, condition = base::local({
     [16:16:18.643] c <- base::c
     [16:16:18.643] inherits <- base::inherits
     [16:16:18.643] invokeRestart <- base::invokeRestart
     [16:16:18.643] length <- base::length
     [16:16:18.643] list <- base::list
     [16:16:18.643] seq.int <- base::seq.int
     [16:16:18.643] signalCondition <- base::signalCondition
     [16:16:18.643] sys.calls <- base::sys.calls
     [16:16:18.643] Sys.time <- base::Sys.time
     [16:16:18.643] `[[` <- base::`[[`
     [16:16:18.643] `+` <- base::`+`
     [16:16:18.643] `<<-` <- base::`<<-`
     [16:16:18.643] sysCalls <- function(calls = sys.calls(), from = 1L) {
     [16:16:18.643] calls[seq.int(from = from + 12L, to = length(calls) -
     [16:16:18.643] 3L)]
     [16:16:18.643] }
     [16:16:18.643] function(cond) {
     [16:16:18.643] if (inherits(cond, "error")) {
     [16:16:18.643] ...future.conditions[[length(...future.conditions) +
     [16:16:18.643] 1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),
     [16:16:18.643] cond$call), timestamp = Sys.time(), signaled = 0L)
     [16:16:18.643] signalCondition(cond)
     [16:16:18.643] }
     [16:16:18.643] else if (inherits(cond, "condition")) {
     [16:16:18.643] signal <- FALSE && inherits(cond, character(0))
     [16:16:18.643] ...future.conditions[[length(...future.conditions) +
     [16:16:18.643] 1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
     [16:16:18.643] if (!signal) {
     [16:16:18.643] muffleCondition <- function (cond)
     [16:16:18.643] {
     [16:16:18.643] inherits <- base::inherits
     [16:16:18.643] invokeRestart <- base::invokeRestart
     [16:16:18.643] muffled <- FALSE
     [16:16:18.643] if (inherits(cond, "message")) {
     [16:16:18.643] invokeRestart("muffleMessage")
     [16:16:18.643] muffled <- TRUE
     [16:16:18.643] }
     [16:16:18.643] else if (inherits(cond, "warning")) {
     [16:16:18.643] invokeRestart("muffleWarning")
     [16:16:18.643] muffled <- TRUE
     [16:16:18.643] }
     [16:16:18.643] else if (inherits(cond, "condition")) {
     [16:16:18.643] computeRestarts <- base::computeRestarts
     [16:16:18.643] grepl <- base::grepl
     [16:16:18.643] is.null <- base::is.null
     [16:16:18.643] restarts <- computeRestarts(cond)
     [16:16:18.643] for (restart in restarts) {
     [16:16:18.643] name <- restart$name
     [16:16:18.643] if (is.null(name))
     [16:16:18.643] next
     [16:16:18.643] if (!grepl("^muffle", name))
     [16:16:18.643] next
     [16:16:18.643] invokeRestart(restart)
     [16:16:18.643] muffled <- TRUE
     [16:16:18.643] break
     [16:16:18.643] }
     [16:16:18.643] }
     [16:16:18.643] invisible(muffled)
     [16:16:18.643] }
     [16:16:18.643] muffleCondition(cond)
     [16:16:18.643] }
     [16:16:18.643] }
     [16:16:18.643] }
     [16:16:18.643] }))
     [16:16:18.643] }, error = function(ex) {
     [16:16:18.643] base::structure(base::list(value = NULL, visible = NULL,
     [16:16:18.643] conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,
     [16:16:18.643] ...future.rng), version = "1.8"), class = "FutureResult")
     [16:16:18.643] }, finally = {
     [16:16:18.643] {
     [16:16:18.643] {
     [16:16:18.643] base::options(mc.cores = ...future.mc.cores.old)
     [16:16:18.643] }
     [16:16:18.643] future::plan(list(function (expr, envir = parent.frame(),
     [16:16:18.643] substitute = TRUE, lazy = FALSE, seed = NULL,
     [16:16:18.643] globals = TRUE, workers = availableCores(constraints = "multicore"),
     [16:16:18.643] earlySignal = FALSE, label = NULL, ...)
     [16:16:18.643] {
     [16:16:18.643] if (substitute)
     [16:16:18.643] expr <- substitute(expr)
     [16:16:18.643] if (is.function(workers))
     [16:16:18.643] workers <- workers()
     [16:16:18.643] workers <- as.integer(workers)
     [16:16:18.643] stop_if_not(is.finite(workers), workers >= 1L)
     [16:16:18.643] if (workers == 1L || !supportsMulticore(warn = TRUE)) {
     [16:16:18.643] return(sequential(expr, envir = envir, substitute = FALSE,
     [16:16:18.643] lazy = lazy, seed = seed, globals = globals,
     [16:16:18.643] local = TRUE, label = label, ...))
     [16:16:18.643] }
     [16:16:18.643] oopts <- options(mc.cores = workers)
     [16:16:18.643] on.exit(options(oopts))
     [16:16:18.643] future <- MulticoreFuture(expr = expr, envir = envir,
     [16:16:18.643] substitute = FALSE, lazy = lazy, seed = seed,
     [16:16:18.643] globals = globals, workers = workers, earlySignal = earlySignal,
     [16:16:18.643] label = label, ...)
     [16:16:18.643] if (!future$lazy)
     [16:16:18.643] future <- run(future)
     [16:16:18.643] invisible(future)
     [16:16:18.643] }), .cleanup = FALSE, .init = FALSE)
     [16:16:18.643] }
     [16:16:18.643] base::options(...future.oldOptions)
     [16:16:18.643] })
     [16:16:18.643] Sys.time
     [16:16:18.643] if (base::is.na(TRUE)) {
     [16:16:18.643] }
     [16:16:18.643] else {
     [16:16:18.643] base::sink(type = "output", split = FALSE)
     [16:16:18.643] if (TRUE) {
     [16:16:18.643] ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
     [16:16:18.643] }
     [16:16:18.643] else {
     [16:16:18.643] ...future.result["stdout"] <- base::list(NULL)
     [16:16:18.643] }
     [16:16:18.643] base::close(...future.stdout)
     [16:16:18.643] ...future.stdout <- NULL
     [16:16:18.643] }
     [16:16:18.643] ...future.result$conditions <- ...future.conditions
     [16:16:18.643] ...future.result
     [16:16:18.643] }
     [16:16:18.646] requestCore(): workers = 2
     [16:16:18.648] MulticoreFuture started
     [16:16:18.651] plan(): Setting new future strategy stack:
     [16:16:18.651] List of future strategies:
     [16:16:18.651] 1. sequential:
     [16:16:18.651] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, local = TRUE, earlySignal = FALSE, label = NULL, ...)
     [16:16:18.651] - tweaked: FALSE
     [16:16:18.651] - call: NULL
     [16:16:18.666] plan(): nbrOfWorkers() = 1
     [16:16:18.669] plan(): Setting new future strategy stack:
     [16:16:18.669] List of future strategies:
     [16:16:18.669] 1. multicore:
     [16:16:18.669] - args: function (expr, envir = parent.frame(), substitute = TRUE, lazy = FALSE, seed = NULL, globals = TRUE, workers = availableCores(constraints = "multicore"), earlySignal = FALSE, label = NULL, ...)
     [16:16:18.669] - tweaked: FALSE
     [16:16:18.669] - call: plan(multicore)
     [16:16:18.671] plan(): nbrOfWorkers() = 2
     Number of OpenMP threads in 'MulticoreFuture' future: 24
     Error: !enable && nthreads == 1L is not TRUE
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Package future.apply

Current CRAN status: OK: 13

Package future.BatchJobs

Current CRAN status: OK: 13

Package future.batchtools

Current CRAN status: OK: 13

Package future.callr

Current CRAN status: OK: 13

Package globals

Current CRAN status: OK: 13

Package listenv

Current CRAN status: OK: 13

Package matrixStats

Current CRAN status: NOTE: 8, OK: 5

Version: 0.55.0
Check: installed package size
Result: NOTE
     installed size is 11.3Mb
     sub-directories of 1Mb or more:
     libs 10.5Mb
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-windows-ix86+x86_64, r-devel-windows-ix86+x86_64-gcc8, r-patched-solaris-x86, r-release-windows-ix86+x86_64, r-release-osx-x86_64, r-oldrel-windows-ix86+x86_64, r-oldrel-osx-x86_64

Package profmem

Current CRAN status: OK: 13

Package progressr

Current CRAN status: NOTE: 2, OK: 11

Version: 0.4.0
Check: dependencies in R code
Result: NOTE
    No protocol specified
    No protocol specified
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package PSCBS

Current CRAN status: OK: 13

Package R.cache

Current CRAN status: OK: 13

Package R.devices

Current CRAN status: ERROR: 1, OK: 12

Version: 2.16.1
Check: tests
Result: ERROR
     Running ‘DevEvalFileProduct.R’
     Running ‘DevEvalProduct.R’
     Running ‘capabilitiesX11.R’
     Running ‘capturePlot.R’
     Running ‘dataURI.R’
     Running ‘devAll.R’
     Running ‘devDump.R’
     Running ‘devEqualTypes.R’
     Running ‘devEval,error.R’
     Running ‘devEval.R’ [9s/25s]
     Running ‘devIsInteractive.R’
     Running ‘devIsOpen.R’
     Running ‘devList.R’
     Running ‘devListIndexOf.R’
     Running ‘devNew.R’
     Running ‘devOptions.R’
     Running ‘devSet.R’
     Running ‘devTypeName.R’
     Running ‘favicon.R’
     Running ‘toNNN.R’
     Running ‘withPar.R’
    Running the tests in ‘tests/devEval.R’ failed.
    Complete output:
     > message("*** devEval() ...")
     *** devEval() ...
     >
     > library("R.devices")
     R.devices v2.16.1 successfully loaded. See ?R.devices for help.
     > library("R.utils")
     Loading required package: R.oo
     Loading required package: R.methodsS3
     R.methodsS3 v1.8.0 (2020-02-14 07:10:20 UTC) successfully loaded. See ?R.methodsS3 for help.
     R.oo v1.23.0 successfully loaded. See ?R.oo for help.
    
     Attaching package: 'R.oo'
    
     The following object is masked from 'package:R.methodsS3':
    
     throw
    
     The following objects are masked from 'package:methods':
    
     getClasses, getMethods
    
     The following objects are masked from 'package:base':
    
     attach, detach, load, save
    
     R.utils v2.9.2 successfully loaded. See ?R.utils for help.
    
     Attaching package: 'R.utils'
    
     The following object is masked from 'package:utils':
    
     timestamp
    
     The following objects are masked from 'package:base':
    
     cat, commandArgs, getOption, inherits, isOpen, nullfile, parse,
     warnings
    
     > graphics.off()
     >
     > png <- grDevices::png
     > jpeg <- grDevices::jpeg
     > tiff <- grDevices::tiff
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # Various types of single and multiple device outputs
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - single and multiple device outputs ...")
     *** devEval() - single and multiple device outputs ...
     >
     > types <- list(
     + character(0L),
     + "png",
     + "jpg",
     + "nulldev",
     + c("png", "png", "jpeg"),
     + "png,nulldev,pdf"
     + )
     >
     > for (type in types) {
     + cat("Device types: ", paste(sQuote(type), collapse=", "), "\n", sep="")
     + devList0 <- devList()
     + res <- devEval(type, name="multi", aspectRatio=2/3, {
     + plot(1:10)
     + })
     + print(res)
     + stopifnot(length(res) == length(unlist(strsplit(type, split=","))))
     + stopifnot(all.equal(devList(), devList0))
     + }
     Device types:
     character(0)
     Device types: 'png'
     [1] "figures/multi.png"
     Device types: 'jpg'
     [1] "figures/multi.jpg"
     Device types: 'nulldev'
     [1] "/dev/null"
     Device types: 'png', 'png', 'jpeg'
     $png
     [1] "figures/multi.png"
    
     $png
     [1] "figures/multi.png"
    
     $jpeg
     [1] "figures/multi.jpg"
    
     Device types: 'png,nulldev,pdf'
     $png
     [1] "figures/multi.png"
    
     $nulldev
     [1] "/dev/null"
    
     $pdf
     [1] "figures/multi.pdf"
    
     >
     > # Sanity checks
     > print(devList())
     named integer(0)
     > stopifnot(length(devList()) == 0L)
     >
     > message("*** devEval() - single and multiple device outputs ... DONE")
     *** devEval() - single and multiple device outputs ... DONE
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # With 'initially' and 'finally' expression
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - initially and finally ...")
     *** devEval() - initially and finally ...
     >
     > devList0 <- devList()
     > devEval(c("png", "jpg"), name="count", {
     + plot(1:10)
     + count <- count + 1L
     + }, initially = {
     + # Emulate an overhead
     + cat("Initiate...")
     + count <- 0L
     + Sys.sleep(1)
     + cat("done\n")
     + }, finally = {
     + cat("Number of image files created: ", count, "\n", sep="")
     + })
     Initiate...done
     Number of image files created: 2
     $png
     [1] "figures/count.png"
    
     $jpeg
     [1] "figures/count.jpg"
    
     > stopifnot(all.equal(devList(), devList0))
     >
     > # Sanity checks
     > print(devList())
     named integer(0)
     > stopifnot(length(devList()) == 0L)
     >
     > message("*** devEval() - initially and finally ... DONE")
     *** devEval() - initially and finally ... DONE
     >
     >
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > # Try several devices until first successful device is found
     > # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     > message("*** devEval() - first successful device ...")
     *** devEval() - first successful device ...
     >
     > types <- list(
     + "png|jpg|pdf", # PNG, JPG and then PDF
     + "dummy|png|jpg|pdf", # "Non-existing", PNG, JPG and then PDF
     + "quartz|x11|windows", # Any interactive device (depending on OS)
     + c("png|jpg", "x11|windows"), # PNG or JPG and then x11 or windows
     + "eps|postscript|pdf", # EPS, Postscript or PDF
     + "jpeg2|jpeg", # JPEG via bitmap() or via jpeg()
     + "png,jpg|x11|windows", # == c("png", "jpg|x11|windows")
     + "nulldev|jpeg" # NULL devices, otherwise jpeg
     + )
     >
     > if (!capabilitiesX11()) {
     + message("Skipping test for X11")
     + types <- lapply(types, FUN=function(x) gsub("x11|", "", x, fixed=TRUE))
     + }
     >
     > devList0 <- devList()
     >
     > for (type in types) {
     + printf("Any of %s\n", paste(sQuote(type), collapse=" + "))
     +
     + # Use try-catch in case not supported on some test systems
     + tryCatch({
     + res <- devEval(type, name="any", aspectRatio=2/3, scale=1.2, {
     + plot(100:1)
     + })
     + printf("Result: %s (%s)\n\n", sQuote(res), attr(res, "type"))
     +
     + if (length(devList()) > 0) devOff()
     + }, error = function(ex) {
     + printf("Failed: %s\n\n", sQuote(ex$message))
     + })
     + } # for (type ...)
     Any of 'png|jpg|pdf'
     Any of 'dummy|png|jpg|pdf'
     Any of 'quartz|x11|windows'
     Failed: 'Failed to open graphics device: quartz'
    
     Any of 'png|jpg' + 'x11|windows'
     Any of 'eps|postscript|pdf'
     Any of 'jpeg2|jpeg'
     Any of 'png,jpg|x11|windows'
    
     *** caught segfault ***
     address f7f76018, cause 'memory not mapped'
    
     Traceback:
     1: .External2(C_X11, d$display, d$width, d$height, d$pointsize, d$gamma, d$colortype, d$maxcubesize, d$bg, d$canvas, d$fonts, NA_integer_, d$xpos, d$ypos, d$title, type, antialias, d$family)
     2: (function (display = "", width, height, pointsize, gamma, bg, canvas, fonts, family, xpos, ypos, title, type, antialias, ...) { if (display != "XImage") { check <- Sys.getenv("_R_CHECK_SCREEN_DEVICE_", "") msg <- "screen devices should not be used in examples etc" if (identical(check, "stop")) stop(msg, domain = NA) else if (identical(check, "warn")) warning(msg, immediate. = TRUE, noBreaks. = TRUE, domain = NA) } if (display == "" && .Platform$GUI == "AQUA" && is.na(Sys.getenv("DISPLAY", NA))) Sys.setenv(DISPLAY = ":0") new <- list() if (!missing(display)) new$display <- display if (!missing(width)) new$width <- width if (!missing(height)) new$height <- height if (!missing(gamma)) new$gamma <- gamma if (!missing(pointsize)) new$pointsize <- pointsize if (!missing(bg)) new$bg <- bg if (!missing(canvas)) new$canvas <- canvas if (!missing(xpos)) new$xpos <- xpos if (!missing(ypos)) new$ypos <- ypos if (!missing(title)) new$title <- title if (!checkIntFormat(new$title)) stop("invalid 'title'") if (!missing(type)) { new$type <- match.arg(type, c("Xlib", "cairo", "nbcairo", "dbcairo")) if (!capabilities("cairo") && type != "Xlib") warning("cairo-based types are not supported on this build - using \"Xlib\"") } if (!missing(family)) new$family <- family if (!missing(fonts)) new$fonts <- fonts if (!missing(antialias) && type != "Xlib") new$antialias <- match.arg(antialias, aa.cairo) d <- check.options(new, name.opt = ".X11.Options", envir = .X11env) if (d$type == "Xlib" && !missing(family)) { fns <- X11Fonts() if (!family %in% names(fns)) stop("unknown family for X11(type = \"XLib\")") d$fonts[1] <- fns[[family]] } type <- if (capabilities("cairo")) switch(d$type, cairo = 1L, nbcairo = 2L, dbcairo = 3L, 0L) else 0L if (display == "XImage") type <- 0L antialias <- match(d$antialias, aa.cairo) if (grepl("darwin", R.version$os)) check_for_XQuartz() .External2(C_X11, d$display, d$width, d$height, d$pointsize, d$gamma, d$colortype, d$maxcubesize, d$bg, d$canvas, d$fonts, NA_integer_, d$xpos, d$ypos, d$title, type, antialias, d$family) invisible()})()
     3: do.call(typeT, args = args)
     4: devNew(type, which = fullname, ..., .allowUnknownArgs = .allowUnknownArgs)
     5: devEval(type = type, expr = expr, initially = NULL, finally = NULL, envir = envir, name = nameOrg, tags = tags, sep = sep, ..., ext = ext, filename = filename, path = path, field = field, onIncomplete = onIncomplete, force = force, .exprAsIs = TRUE, .allowUnknownArgs = TRUE)
     6: FUN(X[[i]], ...)
     7: lapply(types, FUN = function(type) { devEval(type = type, expr = expr, initially = NULL, finally = NULL, envir = envir, name = nameOrg, tags = tags, sep = sep, ..., ext = ext, filename = filename, path = path, field = field, onIncomplete = onIncomplete, force = force, .exprAsIs = TRUE, .allowUnknownArgs = TRUE)})
     8: devEval(type, name = "any", aspectRatio = 2/3, scale = 1.2, { plot(100:1)})
     9: doTryCatch(return(expr), name, parentenv, handler)
     10: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     11: tryCatchList(expr, classes, parentenv, handlers)
     12: tryCatch({ res <- devEval(type, name = "any", aspectRatio = 2/3, scale = 1.2, { plot(100:1) }) printf("Result: %s (%s)\n\n", sQuote(res), attr(res, "type")) if (length(devList()) > 0) devOff()}, error = function(ex) { printf("Failed: %s\n\n", sQuote(ex$message))})
     An irrecoverable exception occurred. R is aborting now ...
Flavor: r-patched-solaris-x86

Package R.filesets

Current CRAN status: OK: 13

Package R.huge

Current CRAN status: OK: 13

Package R.matlab

Current CRAN status: OK: 13

Package R.methodsS3

Current CRAN status: OK: 13

Package R.oo

Current CRAN status: OK: 13

Package R.rsp

Current CRAN status: NOTE: 2, OK: 11

Version: 0.43.2
Check: dependencies in R code
Result: NOTE
    No protocol specified
    No protocol specified
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64

Package R.utils

Current CRAN status: OK: 13

Package startup

Current CRAN status: NOTE: 2, OK: 11

Version: 0.14.0
Check: dependencies in R code
Result: NOTE
    No protocol specified
    No protocol specified
Flavors: r-release-osx-x86_64, r-oldrel-osx-x86_64