The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.
Last updated on 2026-06-30 17:51:26 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.10.0 | 5.87 | 141.35 | 147.22 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.10.0 | 4.24 | 97.64 | 101.88 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2.10.0 | 11.00 | 391.49 | 402.49 | OK | |
| r-devel-linux-x86_64-fedora-gcc | 2.10.0 | 11.00 | 412.29 | 423.29 | OK | |
| r-devel-windows-x86_64 | 2.10.0 | 11.00 | 142.00 | 153.00 | OK | |
| r-patched-linux-x86_64 | 2.9.0 | 8.39 | 142.98 | 151.37 | OK | |
| r-release-linux-x86_64 | 2.10.0 | OK | ||||
| r-release-macos-arm64 | 2.10.0 | 2.00 | 33.00 | 35.00 | OK | |
| r-release-macos-x86_64 | 2.10.0 | 5.00 | 165.00 | 170.00 | OK | |
| r-release-windows-x86_64 | 2.10.0 | 11.00 | 148.00 | 159.00 | OK | |
| r-oldrel-macos-arm64 | 2.10.0 | 2.00 | 36.00 | 38.00 | ERROR | |
| r-oldrel-macos-x86_64 | 2.10.0 | 5.00 | 133.00 | 138.00 | OK | |
| r-oldrel-windows-x86_64 | 2.10.0 | 15.00 | 172.00 | 187.00 | OK |
Version: 2.10.0
Check: tests
Result: ERROR
Running ‘testthat.R’ [13s/7s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
> library(loo)
This is loo version 2.10.0
- Online documentation and vignettes at mc-stan.org/loo
- As of v2.0.0 loo defaults to 1 core but we recommend using as many as possible. Use the 'cores' argument or set options(mc.cores = NUM_CORES) for an entire session.
> library(testthat)
Attaching package: 'testthat'
The following object is masked from 'package:loo':
compare
> Sys.setenv("R_TESTS" = "")
> test_check("loo")
Starting 2 test processes.
> test_loo_and_waic.R:
> test_loo_and_waic.R: *** caught segfault ***
> test_loo_and_waic.R: address 0x110, cause 'invalid permissions'
> test_loo_and_waic.R:
> test_loo_and_waic.R: *** caught segfault ***
> test_loo_and_waic.R: address 0x110, cause 'invalid permissions'
> test_loo_and_waic.R:
> test_loo_and_waic.R: Traceback:
> test_loo_and_waic.R:
> test_loo_and_waic.R: Traceback:
> test_loo_and_waic.R: 1: outer(X, Y)
> test_loo_and_waic.R: 2: -theta %o% x
> test_loo_and_waic.R: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
> test_loo_and_waic.R: 4: psis_smooth_tail(lw_tail, cutoff)
> test_loo_and_waic.R: 5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
> test_loo_and_waic.R: 1: outer(X, Y)
> test_loo_and_waic.R: 2: -theta %o% x 6:
> test_loo_and_waic.R: FUN(X[[i]], ...)
> test_loo_and_waic.R: 7: lapply(X = S, FUN = FUN, ...)
> test_loo_and_waic.R: 8: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
> test_loo_and_waic.R: 4: psis_smooth_tail(lw_tail, cutoff)doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
> test_loo_and_waic.R: 6:
> test_loo_and_waic.R: FUN(X[[i]], ...) 9:
> test_loo_and_waic.R: tryCatchOne(expr, names, parentenv, handlers[[1L]]) 7:
> test_loo_and_waic.R: lapply(X = S, FUN = FUN, ...)10:
> test_loo_and_waic.R: 8: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 10: 11: tryCatchList(expr, classes, parentenv, handlers)tryCatch(expr, error = function(e) {
> test_loo_and_waic.R: call <- conditionCall(e)11: if (!is.null(call)) {tryCatch(expr, error = function(e) { if (identical(call[[1L]], quote(doTryCatch))) call <- conditionCall(e) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] if (!is.null(call)) { w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (identical(call[[1L]], quote(doTryCatch))) if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] prefix <- paste0(prefix, "\n ") w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") } if (is.na(w)) else prefix <- "Error : " w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) msg <- paste0(prefix, conditionMessage(e), "\n") prefix <- paste0(prefix, "\n ") .Internal(seterrmessage(msg[1L])) } if (!silent && isTRUE(getOption("show.error.messages"))) { else prefix <- "Error : " cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))}) msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
> test_loo_and_waic.R:
> test_loo_and_waic.R: 12: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 13: 13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
> test_loo_and_waic.R: 14: FUN(X[[i]], ...)
> test_loo_and_waic.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_and_waic.R: 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
> test_loo_and_waic.R: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]))
> test_loo_and_waic.R: 17: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, method = method)
> test_loo_and_waic.R: 18: importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores,
> test_loo_and_waic.R: 14: FUN(X[[i]], ...)
> test_loo_and_waic.R: method = is_method)
> test_loo_and_waic.R: 19: loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_and_waic.R: 16: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]))
> test_loo_and_waic.R: 17: 20: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, loo(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R: 21: withCallingHandlers(expr, warning = function(w) if (inherits(w, method = method) classes)) tryInvokeRestart("muffleWarning"))
> test_loo_and_waic.R:
> test_loo_and_waic.R: 18: 22: importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) method = is_method)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 23: 19: eval(code, test_env)loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 24: 20: eval(code, test_env)loo(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 25: 21: withCallingHandlers({withCallingHandlers(expr, warning = function(w) if (inherits(w, eval(code, test_env) classes)) tryInvokeRestart("muffleWarning")) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) {22: skip("On CRAN")suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) }
> test_loo_and_waic.R: else if (!new_expectations && skip_on_empty) {23: skip_empty()eval(code, test_env) }
> test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {24: if (on_cran()) {eval(code, test_env) skip(paste0("{", e$package, "} is not installed."))
> test_loo_and_waic.R: }25: }, snapshot_on_cran = function(cnd) {withCallingHandlers({ snapshot_skipped <<- TRUE eval(code, test_env) invokeRestart("muffle_cran_snapshot") new_expectations <- the$test_expectations > starting_expectations}, skip = handle_skip, warning = handle_warning, message = handle_message, if (snapshot_skipped) { error = handle_error, interrupt = handle_interrupt) skip("On CRAN")
> test_loo_and_waic.R: }26: else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) {doTryCatch(return(expr), name, parentenv, handler) skip(paste0("{", e$package, "} is not installed."))
> test_loo_and_waic.R: }27: }, snapshot_on_cran = function(cnd) {tryCatchOne(expr, names, parentenv, handlers[[1L]]) snapshot_skipped <<- TRUE
> test_loo_and_waic.R: invokeRestart("muffle_cran_snapshot")28: }, skip = handle_skip, warning = handle_warning, message = handle_message, tryCatchList(expr, classes, parentenv, handlers) error = handle_error, interrupt = handle_interrupt)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 29: 26: tryCatch(withCallingHandlers({doTryCatch(return(expr), name, parentenv, handler) eval(code, test_env)
> test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations27: if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed."))tryCatchOne(expr, names, parentenv, handlers[[1L]]) }
> test_loo_and_waic.R: }, snapshot_on_cran = function(cnd) {28: snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 30: doWithOneRestart(return(expr), restart)
> test_loo_and_waic.R: 31: tryCatchList(expr, classes, parentenv, handlers)withOneRestart(expr, restarts[[1L]])
> test_loo_and_waic.R: 29: tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: 32: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) } }}, snapshot_on_cran = function(cnd) {}, expectation = handle_expectation, packageNotFoundError = function(e) { snapshot_skipped <<- TRUE if (on_cran()) { invokeRestart("muffle_cran_snapshot") skip(paste0("{", e$package, "} is not installed."))}, skip = handle_skip, warning = handle_warning, message = handle_message, } error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 30: doWithOneRestart(return(expr), restart)}, snapshot_on_cran = function(cnd) {
> test_loo_and_waic.R: snapshot_skipped <<- TRUE31: invokeRestart("muffle_cran_snapshot")withOneRestart(expr, restarts[[1L]])}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal), end_test = function() { })
> test_loo_and_waic.R: 33: test_code(code, parent.frame())
> test_loo_and_waic.R: 34: test_that("loo with cores=1 and cores=2 gives same results",
> test_loo_and_waic.R: 32: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations { loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) expect_equal(loo1$estimates, loo2$estimates) })
> test_loo_and_waic.R: 35: eval(code, test_env)
> test_loo_and_waic.R: if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty()36: eval(code, test_env)
> test_loo_and_waic.R: 37: withCallingHandlers({ }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) } eval(code, test_env)}, snapshot_on_cran = function(cnd) { new_expectations <- the$test_expectations > starting_expectations snapshot_skipped <<- TRUE if (snapshot_skipped) { invokeRestart("muffle_cran_snapshot") skip("On CRAN")}, skip = handle_skip, warning = handle_warning, message = handle_message, } error = handle_error, interrupt = handle_interrupt), error = handle_fatal), else if (!new_expectations && skip_on_empty) { end_test = function() { skip_empty() }) }
> test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {33: if (on_cran()) {test_code(code, parent.frame()) skip(paste0("{", e$package, "} is not installed."))
> test_loo_and_waic.R: }34: }, snapshot_on_cran = function(cnd) {test_that("loo with cores=1 and cores=2 gives same results", snapshot_skipped <<- TRUE { invokeRestart("muffle_cran_snapshot") loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, }, skip = handle_skip, warning = handle_warning, message = handle_message, cores = 2)) error = handle_error, interrupt = handle_interrupt) expect_equal(loo1$estimates, loo2$estimates)
> test_loo_and_waic.R: })
> test_loo_and_waic.R: 35: eval(code, test_env)
> test_loo_and_waic.R: 38: 36: doTryCatch(return(expr), name, parentenv, handler)eval(code, test_env)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 39: 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])withCallingHandlers({
> test_loo_and_waic.R: 40: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 41: eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN")tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } } else if (!new_expectations && skip_on_empty) { else if (!new_expectations && skip_on_empty) { skip_empty() skip_empty() } }}, expectation = handle_expectation, packageNotFoundError = function(e) {}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE
> test_loo_and_waic.R: skip(paste0("{", e$package, "} is not installed.")) invokeRestart("muffle_cran_snapshot") }}, snapshot_on_cran = function(cnd) {}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 42: doWithOneRestart(return(expr), restart)
> test_loo_and_waic.R: 43: withOneRestart(expr, restarts[[1L]])
> test_loo_and_waic.R: snapshot_skipped <<- TRUE44: invokeRestart("muffle_cran_snapshot")withRestarts(tryCatch(withCallingHandlers({}, skip = handle_skip, warning = handle_warning, message = handle_message, eval(code, test_env) error = handle_error, interrupt = handle_interrupt) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) {38: skip("On CRAN")doTryCatch(return(expr), name, parentenv, handler) } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_and_waic.R: if (on_cran()) {39: skip(paste0("{", e$package, "} is not installed."))tryCatchOne(expr, names, parentenv, handlers[[1L]]) }
> test_loo_and_waic.R: }, snapshot_on_cran = function(cnd) {40: snapshot_skipped <<- TRUEtryCatchList(expr, classes, parentenv, handlers) invokeRestart("muffle_cran_snapshot")
> test_loo_and_waic.R: }, skip = handle_skip, warning = handle_warning, message = handle_message, 41: error = handle_error, interrupt = handle_interrupt), error = handle_fatal), tryCatch(withCallingHandlers({ end_test = function() { eval(code, test_env) }) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) {45: skip("On CRAN")test_code(code = exprs, env = env, reporter = get_reporter() %||% } StopReporter$new()) else if (!new_expectations && skip_on_empty) {
> test_loo_and_waic.R: 46: source_file(path, env = env(env), desc = desc, shuffle = shuffle, error_call = error_call)
> test_loo_and_waic.R: skip_empty()47: }test_one_file(path, env = the$testing_env, shuffle = shuffle)}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_and_waic.R: if (on_cran()) {48: skip(paste0("{", e$package, "} is not installed."))doTryCatch(return(expr), name, parentenv, handler) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message,
> test_loo_and_waic.R: 49: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_and_waic.R: 50: error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 42: doWithOneRestart(return(expr), restart)
> test_loo_and_waic.R: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 51: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n")43: NULLwithOneRestart(expr, restarts[[1L]])})
> test_loo_and_waic.R:
> test_loo_and_waic.R: 44: 52: withRestarts(tryCatch(withCallingHandlers({with_reporter(multi, test_one_file(path, env = the$testing_env, eval(code, test_env) shuffle = shuffle)) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty()53: asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_and_waic.R: 54: (function (path, shuffle) }{}, expectation = handle_expectation, packageNotFoundError = function(e) { asNamespace("testthat")$queue_task(path, shuffle) if (on_cran()) {})(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) skip(paste0("{", e$package, "} is not installed."))
> test_loo_and_waic.R: }55: }, snapshot_on_cran = function(cnd) {(function (what, args, quote = FALSE, envir = parent.frame()) snapshot_skipped <<- TRUE{ invokeRestart("muffle_cran_snapshot") if (!is.list(args)) }, skip = handle_skip, warning = handle_warning, message = handle_message, stop("second argument must be a list") error = handle_error, interrupt = handle_interrupt), error = handle_fatal), if (quote) end_test = function() { args <- lapply(args, enquote) }) .Internal(do.call(what, args, envir))
> test_loo_and_waic.R: })(base::quote(function (path, shuffle) 45: {test_code(code = exprs, env = env, reporter = get_reporter() %||% asNamespace("testthat")$queue_task(path, shuffle) StopReporter$new())}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE))
> test_loo_and_waic.R: 56: base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"),
> test_loo_and_waic.R: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 46: quote = TRUE)source_file(path, env = env(env), desc = desc, shuffle = shuffle,
> test_loo_and_waic.R: error_call = error_call)57:
> test_loo_and_waic.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), 47: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, test_one_file(path, env = the$testing_env, shuffle = shuffle) quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d",
> test_loo_and_waic.R: compress = FALSE)48:
> test_loo_and_waic.R: doTryCatch(return(expr), name, parentenv, handler)58:
> test_loo_and_waic.R: base::withCallingHandlers({49: {tryCatchOne(expr, names, parentenv, handlers[[1L]]) NULL
> test_loo_and_waic.R: NULL50: }tryCatchList(expr, classes, parentenv, handlers) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"),
> test_loo_and_waic.R: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 51: quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", tryCatch(code, testthat_abort_reporter = function(cnd) { compress = FALSE) cat(conditionMessage(cnd), "\n") base::flush(base::stdout()) NULL base::flush(base::stderr())}) {
> test_loo_and_waic.R: NULL52: NULLwith_reporter(multi, test_one_file(path, env = the$testing_env, } shuffle = shuffle)) base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) {
> test_loo_and_waic.R: 53: asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_and_waic.R: 54: base::assign(".Traceback", base::.traceback(4), envir = callr_data)(function (path, shuffle) utils::dump.frames("__callr_dump__"){ base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, asNamespace("testthat")$queue_task(path, shuffle) envir = callr_data)})(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) base::rm("__callr_dump__", envir = .GlobalEnv)
> test_loo_and_waic.R: }55: e <- err$process_call(e)(function (what, args, quote = FALSE, envir = parent.frame()) e2 <- err$new_error("error in callr subprocess"){ class <- base::class if (!is.list(args)) class(e2) <- base::c("callr_remote_error", class(e2)) stop("second argument must be a list") e2 <- err$add_trace_back(e2) if (quote) cut <- base::which(e2$trace$scope == "global")[1] args <- lapply(args, enquote) if (!base::is.na(cut)) { .Internal(do.call(what, args, envir)) e2$trace <- e2$trace[-(1:cut), ]})(base::quote(function (path, shuffle) }{ if (callr_data$has_otel) { asNamespace("testthat")$queue_task(path, shuffle) callr_data$otel_span$record_exception(e2)}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), } quote = base::quote(TRUE)) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d",
> test_loo_and_waic.R: ".error"))56: }base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_and_waic.R: }, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) {57: base::assign(".Traceback", base::.traceback(4), envir = callr_data)base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,
> test_loo_and_waic.R: quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) compress = FALSE)
> test_loo_and_waic.R: 58: base::withCallingHandlers({ base::rm("__callr_dump__", envir = .GlobalEnv) { } NULL e <- err$process_call(e) NULL e2 <- err$new_error("error in callr subprocess") } class <- base::class base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (callr_data$has_otel) { if (FALSE) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib base::assign(".Traceback", base::.traceback(4), envir = callr_data) if (base::is.null(e$code)) { utils::dump.frames("__callr_dump__") e$code <- "301" base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, } envir = callr_data) msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, base::rm("__callr_dump__", envir = .GlobalEnv) NULL))) } data <- base::paste0(e$code, " ", base::nchar(msg), "\n", e <- err$process_call(e) msg) e2 <- err$new_error("error in callr subprocess") if (callr_data$has_otel) { class <- base::class callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) pxlib$write_fd(3L, data) cut <- base::which(e2$trace$scope == "global")[1] if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) base::invokeRestart("muffleMessage") } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", }) ".error"))}) }
> test_loo_and_waic.R: }, interrupt = function(e) {59: {doTryCatch(return(expr), name, parentenv, handler) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_and_waic.R: err <- callr_data$err60: if (FALSE) {tryCatchOne(expr, names, parentenv, handlers[[1L]]) base::assign(".Traceback", base::.traceback(4), envir = callr_data)
> test_loo_and_waic.R: 61: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
> test_loo_and_waic.R: 62: utils::dump.frames("__callr_dump__")doTryCatch(return(expr), name, parentenv, handler) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,
> test_loo_and_waic.R: envir = callr_data)63: base::rm("__callr_dump__", envir = .GlobalEnv)tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), } names[nh], parentenv, handlers[[nh]]) e <- err$process_call(e)
> test_loo_and_waic.R: e2 <- err$new_error("error in callr subprocess")64: class <- base::classtryCatchList(expr, classes, parentenv, handlers) class(e2) <- base::c("callr_remote_error", class(e2))
> test_loo_and_waic.R: e2 <- err$add_trace_back(e2)65: cut <- base::which(e2$trace$scope == "global")[1]base::tryCatch(base::withCallingHandlers({ if (!base::is.na(cut)) { { e2$trace <- e2$trace[-(1:cut), ] NULL } NULL if (callr_data$has_otel) { } callr_data$otel_span$record_exception(e2) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), } base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` { pxlib <- callr_data$pxlib NULL if (base::is.null(e$code)) { NULL e$code <- "301" } } base::invisible() msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, }, error = function(e) { NULL))) { data <- base::paste0(e$code, " ", base::nchar(msg), "\n", callr_data <- base::as.environment("tools:callr")$`__callr_data__` msg) err <- callr_data$err if (callr_data$has_otel) { if (FALSE) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) base::assign(".Traceback", base::.traceback(4), envir = callr_data) } utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } pxlib$write_fd(3L, data) e <- err$process_call(e) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { e2 <- err$new_error("error in callr subprocess") base::invokeRestart("cli_message_handled") class <- base::class } class(e2) <- base::c("callr_remote_error", class(e2)) else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { e2 <- err$add_trace_back(e2) base::invokeRestart("muffleMessage") cut <- base::which(e2$trace$scope == "global")[1] } if (!base::is.na(cut)) { }) e2$trace <- e2$trace[-(1:cut), ]}) }
> test_loo_and_waic.R: if (callr_data$has_otel) {59: callr_data$otel_span$record_exception(e2)doTryCatch(return(expr), name, parentenv, handler) }
> test_loo_and_waic.R: base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", 60: ".error"))tryCatchOne(expr, names, parentenv, handlers[[1L]]) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err
> test_loo_and_waic.R: if (FALSE) {61: base::assign(".Traceback", base::.traceback(4), envir = callr_data)tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) utils::dump.frames("__callr_dump__")
> test_loo_and_waic.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, 62: envir = callr_data)doTryCatch(return(expr), name, parentenv, handler) base::rm("__callr_dump__", envir = .GlobalEnv)
> test_loo_and_waic.R: }63: e <- err$process_call(e)tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
> test_loo_and_waic.R: e2 <- err$new_error("error in callr subprocess") names[nh], parentenv, handlers[[nh]]) class <- base::class
> test_loo_and_waic.R: 64: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 65: class(e2) <- base::c("callr_remote_error", class(e2))base::tryCatch(base::withCallingHandlers({ e2 <- err$add_trace_back(e2) { cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154505ecbd782"), callr_data$otel_span$record_exception(e2) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, } quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", compress = FALSE) ".error")) base::flush(base::stdout()) } base::flush(base::stderr())}, callr_message = function(e) { { base::try({ NULL callr_data <- base::as.environment("tools:callr")$`__callr_data__` NULL pxlib <- callr_data$pxlib } if (base::is.null(e$code)) { base::invisible() e$code <- "301"}, error = function(e) { } { msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, callr_data <- base::as.environment("tools:callr")$`__callr_data__` NULL))) err <- callr_data$err data <- base::paste0(e$code, " ", base::nchar(msg), "\n", if (FALSE) { msg) base::assign(".Traceback", base::.traceback(4), envir = callr_data) if (callr_data$has_otel) { utils::dump.frames("__callr_dump__") callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, } envir = callr_data) pxlib$write_fd(3L, data) base::rm("__callr_dump__", envir = .GlobalEnv) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { } base::invokeRestart("cli_message_handled") e <- err$process_call(e) } e2 <- err$new_error("error in callr subprocess") else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { class <- base::class base::invokeRestart("muffleMessage") class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) }) cut <- base::which(e2$trace$scope == "global")[1]}), error = function(e) { if (!base::is.na(cut)) { { e2$trace <- e2$trace[-(1:cut), ] NULL } NULL if (callr_data$has_otel) { } callr_data$otel_span$record_exception(e2) if (FALSE) { } base::try(base::stop(e)) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", } ".error")) if (FALSE) { } base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { {}, interrupt = function(e) { NULL { NULL callr_data <- base::as.environment("tools:callr")$`__callr_data__` } err <- callr_data$err if (FALSE) { if (FALSE) { base::q(save = "no", status = 1) base::assign(".Traceback", base::.traceback(4), envir = callr_data) } utils::dump.frames("__callr_dump__") base::invisible() base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, }) envir = callr_data)
> test_loo_and_waic.R: base::rm("__callr_dump__", envir = .GlobalEnv)An irrecoverable exception occurred. R is aborting now ...
> test_loo_and_waic.R: } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545018b1c86d", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) if (callr_data$has_otel) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { { NULL NULL } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()})
> test_loo_and_waic.R: An irrecoverable exception occurred. R is aborting now ...
Saving _problems/test_loo_and_waic-30.R
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: *** caught segfault ***
> test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: *** caught segfault ***
> test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: Traceback:
> test_loo_predictive_metric.R: 1: outer(X, Y)
> test_loo_predictive_metric.R: 2: -theta %o% x
> test_loo_predictive_metric.R: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
> test_loo_predictive_metric.R: 4: psis_smooth_tail(lw_tail, cutoff)
> test_loo_predictive_metric.R: 5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
> test_loo_predictive_metric.R: 6: FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 7: lapply(X = S, FUN = FUN, ...)
> test_loo_predictive_metric.R: 8: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 10: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 11: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
> test_loo_predictive_metric.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
> test_loo_predictive_metric.R: 13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
> test_loo_predictive_metric.R: 14: FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_predictive_metric.R: 16: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]))
> test_loo_predictive_metric.R: 17: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, method = method)
> test_loo_predictive_metric.R: 18: importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores, method = "psis")
> test_loo_predictive_metric.R: 19: psis.matrix(-LL, r_eff = r_eff, cores = 2)
> test_loo_predictive_metric.R: 20: psis(-LL, r_eff = r_eff, cores = 2)
> test_loo_predictive_metric.R: 21: eval(code, test_env)
> test_loo_predictive_metric.R: 22: eval(code, test_env)
> test_loo_predictive_metric.R: 23: withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt)
> test_loo_predictive_metric.R: 24: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 26: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 27: tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_predictive_metric.R: 28: doWithOneRestart(return(expr), restart)
> test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]])
> test_loo_predictive_metric.R: 30: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) {
> test_loo_predictive_metric.R: skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal), end_test = function() { })
> test_loo_predictive_metric.R: 31: test_code(code = exprs, env = env, reporter = get_reporter() %||% StopReporter$new())
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: Traceback:
> test_loo_predictive_metric.R: 1: outer(X, Y)
> test_loo_predictive_metric.R: 2: -theta %o% x
> test_loo_predictive_metric.R: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
> test_loo_predictive_metric.R: 4: psis_smooth_tail(lw_tail, cutoff)
> test_loo_predictive_metric.R: 5: 32: source_file(path, env = env(env), desc = desc, shuffle = shuffle, error_call = error_call)
> test_loo_predictive_metric.R: 33: test_one_file(path, env = the$testing_env, shuffle = shuffle)
> test_loo_predictive_metric.R: 34: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 6: FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 7:
> test_loo_predictive_metric.R: 35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 36: lapply(X = S, FUN = FUN, ...)tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 8: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 9:
> test_loo_predictive_metric.R: tryCatchOne(expr, names, parentenv, handlers[[1L]])37:
> test_loo_predictive_metric.R: tryCatch(code, testthat_abort_reporter = function(cnd) {10: cat(conditionMessage(cnd), "\n")tryCatchList(expr, classes, parentenv, handlers) NULL
> test_loo_predictive_metric.R: })11:
> test_loo_predictive_metric.R: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) 38: call <- sys.call(-4L)with_reporter(multi, test_one_file(path, env = the$testing_env, dcall <- deparse(call, nlines = 1L) shuffle = shuffle)) prefix <- paste("Error in", dcall, ": ")
> test_loo_predictive_metric.R: LONG <- 75L39: sm <- strsplit(conditionMessage(e), "\n")[[1L]]asNamespace("testthat")$queue_task(path, shuffle) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") }
> test_loo_predictive_metric.R: 40: (function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE))
> test_loo_predictive_metric.R: 41: (function (what, args, quote = FALSE, envir = parent.frame()) else prefix <- "Error : "{ msg <- paste0(prefix, conditionMessage(e), "\n") if (!is.list(args)) .Internal(seterrmessage(msg[1L])) stop("second argument must be a list") if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e)) if (quote) }) args <- lapply(args, enquote) .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_predictive_metric.R: }), base::quote(list("test_loo_predictive_metric.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE))
> test_loo_predictive_metric.R: 42: 12: base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_predictive_metric.R: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
> test_loo_predictive_metric.R: 13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
> test_loo_predictive_metric.R: 43: 14: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", compress = FALSE)FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 16: 44: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]))
> test_loo_predictive_metric.R: 17: base::withCallingHandlers({do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, { method = method) NULL
> test_loo_predictive_metric.R: NULL18: }importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores, base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), method = "psis") base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,
> test_loo_predictive_metric.R: quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", 19: compress = FALSE)psis.matrix(-LL, r_eff = r_eff, cores = 2) base::flush(base::stdout())
> test_loo_predictive_metric.R: base::flush(base::stderr())20: {psis(-LL, r_eff = r_eff, cores = 2) NULL
> test_loo_predictive_metric.R: NULL21: }eval(code, test_env) base::invisible()
> test_loo_predictive_metric.R: }, error = function(e) {22: {eval(code, test_env) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_predictive_metric.R: err <- callr_data$err23: if (FALSE) {withCallingHandlers({ base::assign(".Traceback", base::.traceback(4), envir = callr_data) eval(code, test_env) utils::dump.frames("__callr_dump__") new_expectations <- the$test_expectations > starting_expectations base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, if (snapshot_skipped) { envir = callr_data) skip("On CRAN") base::rm("__callr_dump__", envir = .GlobalEnv) } } else if (!new_expectations && skip_on_empty) { e <- err$process_call(e) skip_empty() e2 <- err$new_error("error in callr subprocess") } class <- base::class}, expectation = handle_expectation, packageNotFoundError = function(e) { class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE } invokeRestart("muffle_cran_snapshot") base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, interrupt = function(e) { {}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt)
> test_loo_predictive_metric.R: 24: doTryCatch(return(expr), name, parentenv, handler) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_predictive_metric.R: err <- callr_data$err25: if (FALSE) {tryCatchOne(expr, names, parentenv, handlers[[1L]]) base::assign(".Traceback", base::.traceback(4), envir = callr_data)
> test_loo_predictive_metric.R: utils::dump.frames("__callr_dump__")26: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, tryCatchList(expr, classes, parentenv, handlers) envir = callr_data)
> test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv)27: }tryCatch(withCallingHandlers({ e <- err$process_call(e) eval(code, test_env) e2 <- err$new_error("error in callr subprocess") new_expectations <- the$test_expectations > starting_expectations class <- base::class if (snapshot_skipped) { class(e2) <- base::c("callr_remote_error", class(e2)) skip("On CRAN") e2 <- err$add_trace_back(e2) } cut <- base::which(e2$trace$scope == "global")[1] else if (!new_expectations && skip_on_empty) { if (!base::is.na(cut)) { skip_empty() e2$trace <- e2$trace[-(1:cut), ] } }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (callr_data$has_otel) { if (on_cran()) { callr_data$otel_span$record_exception(e2) skip(paste0("{", e$package, "} is not installed.")) } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) {
> test_loo_predictive_metric.R: }, snapshot_on_cran = function(cnd) { e$code <- "301" snapshot_skipped <<- TRUE } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) invokeRestart("muffle_cran_snapshot") if (callr_data$has_otel) {}, skip = handle_skip, warning = handle_warning, message = handle_message, callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_predictive_metric.R: 28: doWithOneRestart(return(expr), restart)
> test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]])
> test_loo_predictive_metric.R: 30: base::invokeRestart("muffleMessage")withRestarts(tryCatch(withCallingHandlers({ } eval(code, test_env) }) new_expectations <- the$test_expectations > starting_expectations}) if (snapshot_skipped) {
> test_loo_predictive_metric.R: skip("On CRAN")45: }doTryCatch(return(expr), name, parentenv, handler) else if (!new_expectations && skip_on_empty) {
> test_loo_predictive_metric.R: skip_empty()46: }tryCatchOne(expr, names, parentenv, handlers[[1L]])}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_predictive_metric.R: if (on_cran()) {47: skip(paste0("{", e$package, "} is not installed."))tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) }
> test_loo_predictive_metric.R: }, snapshot_on_cran = function(cnd) {48: snapshot_skipped <<- TRUEdoTryCatch(return(expr), name, parentenv, handler) invokeRestart("muffle_cran_snapshot")
> test_loo_predictive_metric.R: }, skip = handle_skip, warning = handle_warning, message = handle_message, 49: error = handle_error, interrupt = handle_interrupt), error = handle_fatal), tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), end_test = function() { names[nh], parentenv, handlers[[nh]]) })
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 50: 31: tryCatchList(expr, classes, parentenv, handlers)test_code(code = exprs, env = env, reporter = get_reporter() %||%
> test_loo_predictive_metric.R: StopReporter$new())51:
> test_loo_predictive_metric.R: base::tryCatch(base::withCallingHandlers({32: {source_file(path, env = env(env), desc = desc, shuffle = shuffle, NULL error_call = error_call) NULL
> test_loo_predictive_metric.R: }33: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), test_one_file(path, env = the$testing_env, shuffle = shuffle) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,
> test_loo_predictive_metric.R: quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr())34: {doTryCatch(return(expr), name, parentenv, handler) NULL
> test_loo_predictive_metric.R: NULL35: }tryCatchOne(expr, names, parentenv, handlers[[1L]]) base::invisible()
> test_loo_predictive_metric.R: }, error = function(e) {36: {tryCatchList(expr, classes, parentenv, handlers) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_predictive_metric.R: err <- callr_data$err37: if (FALSE) {tryCatch(code, testthat_abort_reporter = function(cnd) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) cat(conditionMessage(cnd), "\n") utils::dump.frames("__callr_dump__") NULL base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, }) envir = callr_data)
> test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv)38: }with_reporter(multi, test_one_file(path, env = the$testing_env, e <- err$process_call(e) shuffle = shuffle)) e2 <- err$new_error("error in callr subprocess")
> test_loo_predictive_metric.R: class <- base::class39: class(e2) <- base::c("callr_remote_error", class(e2))asNamespace("testthat")$queue_task(path, shuffle) e2 <- err$add_trace_back(e2)
> test_loo_predictive_metric.R: cut <- base::which(e2$trace$scope == "global")[1]40: if (!base::is.na(cut)) {(function (path, shuffle) e2$trace <- e2$trace[-(1:cut), ]{ } asNamespace("testthat")$queue_task(path, shuffle) if (callr_data$has_otel) {})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE)) callr_data$otel_span$record_exception(e2)
> test_loo_predictive_metric.R: }41: base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", (function (what, args, quote = FALSE, envir = parent.frame()) { if (!is.list(args)) stop("second argument must be a list") if (quote) ".error")) args <- lapply(args, enquote) } .Internal(do.call(what, args, envir))}, interrupt = function(e) {})(base::quote(function (path, shuffle) {{ callr_data <- base::as.environment("tools:callr")$`__callr_data__` asNamespace("testthat")$queue_task(path, shuffle) err <- callr_data$err}), base::quote(list("test_loo_predictive_metric.R", FALSE)), if (FALSE) { envir = base::quote(<environment>), quote = base::quote(TRUE)) base::assign(".Traceback", base::.traceback(4), envir = callr_data)
> test_loo_predictive_metric.R: utils::dump.frames("__callr_dump__")42: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), envir = callr_data) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, base::rm("__callr_dump__", envir = .GlobalEnv) quote = TRUE) }
> test_loo_predictive_metric.R: e <- err$process_call(e)43: e2 <- err$new_error("error in callr subprocess")base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), class <- base::class base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, class(e2) <- base::c("callr_remote_error", class(e2)) quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", e2 <- err$add_trace_back(e2) compress = FALSE) cut <- base::which(e2$trace$scope == "global")[1]
> test_loo_predictive_metric.R: if (!base::is.na(cut)) {44: e2$trace <- e2$trace[-(1:cut), ]base::withCallingHandlers({ { NULL NULL } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, callr_message = function(e) { } base::try({ base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", compress = FALSE) base::flush(base::stdout()) callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::flush(base::stderr()) pxlib <- callr_data$pxlib { if (base::is.null(e$code)) { NULL e$code <- "301" NULL } } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, base::invisible() NULL)))}, error = function(e) { data <- base::paste0(e$code, " ", base::nchar(msg), "\n", { msg) callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (callr_data$has_otel) { err <- callr_data$err callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { if (FALSE) { base::invokeRestart("cli_message_handled") base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") }
> test_loo_predictive_metric.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { base::q(save = "no", status = 1) class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } base::invisible() if (callr_data$has_otel) {}, interrupt = function(e) { callr_data$otel_span$record_exception(e2) { } NULL base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, interrupt = function(e) { NULL } if (FALSE) { base::q(save = "no", status = 1) } { base::invisible() callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__")}) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,
> test_loo_predictive_metric.R: envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv)An irrecoverable exception occurred. R is aborting now ...
> test_loo_predictive_metric.R: } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) if (callr_data$has_otel) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })})
> test_loo_predictive_metric.R: 45: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 47: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
> test_loo_predictive_metric.R: 48: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 49: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
> test_loo_predictive_metric.R: 50: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 51: base::tryCatch(base::withCallingHandlers({ { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-fun-154507e92bc49"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmp8c5wyl/callr-rs-result-1545053879d8a", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) if (callr_data$has_otel) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { { NULL NULL } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()})
> test_loo_predictive_metric.R: An irrecoverable exception occurred. R is aborting now ...
Saving _problems/test_loo_predictive_metric-4.R
[ FAIL 2 | WARN 1 | SKIP 34 | PASS 847 ]
══ Skipped tests (34) ══════════════════════════════════════════════════════════
• On CRAN (32): 'test_loo_subsampling_cases.R:4:3',
'test_loo_subsampling_cases.R:256:3', 'test_E_loo.R:134:1',
'test_E_loo.R:142:1', 'test_compare.R:91:1', 'test_compare.R:122:1',
'test_compare.R:160:1', 'test_crps.R:27:1',
'test_deprecated_extractors.R:8:1', 'test_deprecated_extractors.R:106:1',
'test_gpdfit.R:1:1', 'test_kfold_helpers.R:139:1',
'test_loo_and_waic.R:23:1', 'test_loo_moment_matching.R:157:1',
'test_loo_moment_matching.R:247:1', 'test_loo_moment_matching.R:365:1',
'test_model_weighting.R:69:1', 'test_print_plot.R:41:1',
'test_print_plot.R:45:1', 'test_print_plot.R:151:1',
'test_print_plot.R:169:1', 'test_print_plot.R:175:1',
'test_print_plot.R:181:1', 'test_psis.R:13:1', 'test_psis.R:39:1',
'test_psislw.R:15:1', 'test_relative_eff.R:7:1', 'test_relative_eff.R:43:3',
'test_loo_subsampling.R:896:3', 'test_loo_subsampling.R:1077:3',
'test_tisis.R:76:1', 'test_tisis.R:213:1'
• Sys.info()[["sysname"]] == "Darwin" && R.version$arch == "aarch64" is TRUE
(2): 'test_loo_moment_matching.R:468:3', 'test_psis.R:157:3'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test_loo_and_waic.R:30:3'): loo with cores=1 and cores=2 gives same results ──
Error in `vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)`: values must be length 1000,
but FUN(X[[1]]) result is length 0
Backtrace:
▆
1. ├─base::suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) at test_loo_and_waic.R:30:3
2. │ └─base::withCallingHandlers(...)
3. ├─loo::loo(LLarr, r_eff = r_eff_arr, cores = 2)
4. └─loo::loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
5. └─loo:::importance_sampling.array(...)
6. └─loo:::do_importance_sampling(...)
7. └─loo:::psis_apply(lw_list, "log_weights", fun_val = numeric(S))
8. └─base::vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)
── Error ('test_loo_predictive_metric.R:4:1'): (code run outside of `test_that()`) ──
Error in `vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)`: values must be length 1000,
but FUN(X[[1]]) result is length 0
Backtrace:
▆
1. ├─loo::psis(-LL, r_eff = r_eff, cores = 2) at test_loo_predictive_metric.R:4:1
2. └─loo:::psis.matrix(-LL, r_eff = r_eff, cores = 2)
3. └─loo:::importance_sampling.matrix(...)
4. └─loo:::do_importance_sampling(...)
5. └─loo:::psis_apply(lw_list, "log_weights", fun_val = numeric(S))
6. └─base::vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)
[ FAIL 2 | WARN 1 | SKIP 34 | PASS 847 ]
Error:
! Test failures.
Execution halted
Flavor: r-oldrel-macos-arm64
These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.