Last updated on 2026-07-15 18:50:39 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.10.0 | 6.19 | 141.46 | 147.65 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.10.0 | 4.60 | 99.24 | 103.84 | 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 | 104.38 | OK | |||
| r-devel-windows-x86_64 | 2.10.0 | 13.00 | 149.00 | 162.00 | OK | |
| r-patched-linux-x86_64 | 2.10.0 | 7.72 | 134.77 | 142.49 | OK | |
| r-release-linux-x86_64 | 2.10.0 | 4.96 | 133.24 | 138.20 | 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 | 12.00 | 156.00 | 168.00 | OK | |
| r-oldrel-macos-arm64 | 2.10.0 | 1.00 | 36.00 | 37.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 | 13.00 | 179.00 | 192.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: 6: FUN(X[[i]], ...)
> test_loo_and_waic.R: 7: lapply(X = S, FUN = FUN, ...)
> test_loo_and_waic.R: 8: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 1: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_and_waic.R: 10: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 11: outer(X, Y)tryCatch(expr, error = function(e) {
> test_loo_and_waic.R: 2: -theta %o% x
> test_loo_and_waic.R: call <- conditionCall(e) 3: if (!is.null(call)) {posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE) if (identical(call[[1L]], quote(doTryCatch)))
> test_loo_and_waic.R: call <- sys.call(-4L) 4: dcall <- deparse(call, nlines = 1L)psis_smooth_tail(lw_tail, cutoff) prefix <- paste("Error in", dcall, ": ")
> test_loo_and_waic.R: LONG <- 75L 5: sm <- strsplit(conditionMessage(e), "\n")[[1L]]is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
> test_loo_and_waic.R: if (is.na(w)) 6: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], FUN(X[[i]], ...) type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : "
> test_loo_and_waic.R: 7: lapply(X = S, FUN = FUN, ...)
> test_loo_and_waic.R: 8: msg <- paste0(prefix, conditionMessage(e), "\n")doTryCatch(return(expr), name, parentenv, handler) .Internal(seterrmessage(msg[1L]))
> test_loo_and_waic.R: if (!silent && isTRUE(getOption("show.error.messages"))) { 9: cat(msg, file = outFile)tryCatchOne(expr, names, parentenv, handlers[[1L]]) .Internal(printDeferredWarnings())
> test_loo_and_waic.R: }10: invisible(structure(msg, class = "try-error", condition = e))tryCatchList(expr, classes, parentenv, handlers)})
> test_loo_and_waic.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 11: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) {13: if (identical(call[[1L]], quote(doTryCatch))) sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L
> test_loo_and_waic.R: sm <- strsplit(conditionMessage(e), "\n")[[1L]]14: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")FUN(X[[i]], ...) if (is.na(w))
> test_loo_and_waic.R: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 15: type = "b")lapply(seq_len(cores), inner.do) if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : "
> 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: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, msg <- paste0(prefix, conditionMessage(e), "\n") method = method) .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) }
> test_loo_and_waic.R: 18: importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, method = is_method)
> test_loo_and_waic.R: invisible(structure(msg, class = "try-error", condition = e))})
> test_loo_and_waic.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)19: loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R: 20: loo(LLarr, r_eff = r_eff_arr, cores = 2)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 13: 21: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))withCallingHandlers(expr, warning = function(w) if (inherits(w,
> test_loo_and_waic.R: classes)) tryInvokeRestart("muffleWarning"))14:
> test_loo_and_waic.R: FUN(X[[i]], ...)22:
> test_loo_and_waic.R: suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))15:
> test_loo_and_waic.R: lapply(seq_len(cores), inner.do)23:
> test_loo_and_waic.R: eval(code, test_env)16:
> 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, 24: method = method)eval(code, test_env)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 18: 25: importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, withCallingHandlers({ method = is_method) eval(code, test_env)
> test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations19: if (snapshot_skipped) {loo.array(LLarr, r_eff = r_eff_arr, cores = 2) skip("On CRAN")
> test_loo_and_waic.R: }20: else if (!new_expectations && skip_on_empty) {loo(LLarr, r_eff = r_eff_arr, cores = 2) skip_empty()
> test_loo_and_waic.R: }21: }, expectation = handle_expectation, packageNotFoundError = function(e) {withCallingHandlers(expr, warning = function(w) if (inherits(w, if (on_cran()) { classes)) tryInvokeRestart("muffleWarning")) skip(paste0("{", e$package, "} is not installed."))
> test_loo_and_waic.R: }22: }, snapshot_on_cran = function(cnd) {suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) snapshot_skipped <<- TRUE
> test_loo_and_waic.R: invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt)
> test_loo_and_waic.R: 26: 23: doTryCatch(return(expr), name, parentenv, handler)eval(code, test_env)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 27: 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])eval(code, test_env)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 28: 25: tryCatchList(expr, classes, parentenv, handlers)withCallingHandlers({
> test_loo_and_waic.R: eval(code, test_env)29: new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") }tryCatch(withCallingHandlers({ else if (!new_expectations && skip_on_empty) { eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } skip_empty() 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}, expectation = handle_expectation, packageNotFoundError = function(e) { invokeRestart("muffle_cran_snapshot") if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE}, skip = handle_skip, warning = handle_warning, message = handle_message, invokeRestart("muffle_cran_snapshot") error = handle_error, interrupt = handle_interrupt)
> test_loo_and_waic.R: 26: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: }, 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: withOneRestart(expr, restarts[[1L]])
> test_loo_and_waic.R: 27: 32: tryCatchOne(expr, names, parentenv, handlers[[1L]])withRestarts(tryCatch(withCallingHandlers({
> test_loo_and_waic.R: eval(code, test_env)28: new_expectations <- the$test_expectations > starting_expectationstryCatchList(expr, classes, parentenv, handlers) if (snapshot_skipped) {
> test_loo_and_waic.R: skip("On CRAN")29: }tryCatch(withCallingHandlers({ else if (!new_expectations && skip_on_empty) { eval(code, test_env) 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") 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), error = handle_fatal), skip("On CRAN") end_test = function() { } }) else if (!new_expectations && skip_on_empty) {
> test_loo_and_waic.R: skip_empty()33: }test_code(code, parent.frame())}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_and_waic.R: if (on_cran()) {34: skip(paste0("{", e$package, "} is not installed."))test_that("loo with cores=1 and cores=2 gives same results", } {}, snapshot_on_cran = function(cnd) { loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, snapshot_skipped <<- TRUE cores = 2)) 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: expect_equal(loo1$estimates, loo2$estimates)doWithOneRestart(return(expr), restart) })
> test_loo_and_waic.R: 35: eval(code, test_env)
> test_loo_and_waic.R: 36:
> test_loo_and_waic.R: eval(code, test_env)31:
> test_loo_and_waic.R: withOneRestart(expr, restarts[[1L]])37:
> test_loo_and_waic.R: withCallingHandlers({32: eval(code, test_env)withRestarts(tryCatch(withCallingHandlers({ new_expectations <- the$test_expectations > starting_expectations eval(code, test_env) if (snapshot_skipped) { new_expectations <- the$test_expectations > starting_expectations skip("On CRAN") if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { } if (on_cran()) {}, expectation = handle_expectation, packageNotFoundError = function(e) { skip(paste0("{", e$package, "} is not installed.")) if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE } invokeRestart("muffle_cran_snapshot")}, snapshot_on_cran = function(cnd) {}, skip = handle_skip, warning = handle_warning, message = handle_message, snapshot_skipped <<- TRUE error = handle_error, interrupt = handle_interrupt), error = handle_fatal), invokeRestart("muffle_cran_snapshot") end_test = function() {}, skip = handle_skip, warning = handle_warning, message = handle_message, }) error = handle_error, interrupt = handle_interrupt)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 33: 38: test_code(code, parent.frame())doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 34: 39: test_that("loo with cores=1 and cores=2 gives same results", tryCatchOne(expr, names, parentenv, handlers[[1L]]) {
> test_loo_and_waic.R: loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, 40: cores = 2)) expect_equal(loo1$estimates, loo2$estimates) })
> test_loo_and_waic.R: 35: tryCatchList(expr, classes, parentenv, handlers)eval(code, test_env)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 41: 36: tryCatch(withCallingHandlers({eval(code, test_env) eval(code, test_env)
> test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations37: if (snapshot_skipped) {withCallingHandlers({ skip("On CRAN") eval(code, test_env) } new_expectations <- the$test_expectations > starting_expectations else if (!new_expectations && skip_on_empty) { if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) } }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE}, snapshot_on_cran = function(cnd) { invokeRestart("muffle_cran_snapshot") snapshot_skipped <<- TRUE}, skip = handle_skip, warning = handle_warning, message = handle_message, invokeRestart("muffle_cran_snapshot") error = handle_error, interrupt = handle_interrupt)}, 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:
> test_loo_and_waic.R: 38: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 39: 44: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) {tryCatchOne(expr, names, parentenv, handlers[[1L]]) skip("On CRAN")
> test_loo_and_waic.R: }40: else if (!new_expectations && skip_on_empty) {tryCatchList(expr, classes, parentenv, handlers) skip_empty()
> test_loo_and_waic.R: }41: }, expectation = handle_expectation, packageNotFoundError = function(e) {tryCatch(withCallingHandlers({ if (on_cran()) { eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } skip(paste0("{", e$package, "} is not installed.")) else if (!new_expectations && skip_on_empty) { } skip_empty()}, snapshot_on_cran = function(cnd) { } snapshot_skipped <<- TRUE}, expectation = handle_expectation, packageNotFoundError = function(e) { invokeRestart("muffle_cran_snapshot") if (on_cran()) {}, skip = handle_skip, warning = handle_warning, message = handle_message, skip(paste0("{", e$package, "} is not installed.")) error = handle_error, interrupt = handle_interrupt), error = handle_fatal), } end_test = function() {}, snapshot_on_cran = function(cnd) { }) snapshot_skipped <<- TRUE
> test_loo_and_waic.R: invokeRestart("muffle_cran_snapshot")45: }, skip = handle_skip, warning = handle_warning, message = handle_message, test_code(code = exprs, env = env, reporter = get_reporter() %||% error = handle_error, interrupt = handle_interrupt), error = handle_fatal) StopReporter$new())
> test_loo_and_waic.R:
> test_loo_and_waic.R: 42: 46: doWithOneRestart(return(expr), restart)source_file(path, env = env(env), desc = desc, shuffle = shuffle,
> test_loo_and_waic.R: error_call = error_call)43:
> test_loo_and_waic.R: withOneRestart(expr, restarts[[1L]])47:
> test_loo_and_waic.R: test_one_file(path, env = the$testing_env, shuffle = shuffle)44:
> test_loo_and_waic.R: withRestarts(tryCatch(withCallingHandlers({48: eval(code, test_env)doTryCatch(return(expr), name, parentenv, handler) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) {49: skip("On CRAN")tryCatchOne(expr, names, parentenv, handlers[[1L]]) }
> test_loo_and_waic.R: else if (!new_expectations && skip_on_empty) {50: skip_empty()tryCatchList(expr, classes, parentenv, handlers) }
> test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {51: if (on_cran()) {tryCatch(code, testthat_abort_reporter = function(cnd) { skip(paste0("{", e$package, "} is not installed.")) cat(conditionMessage(cnd), "\n") } NULL}, snapshot_on_cran = function(cnd) {}) snapshot_skipped <<- TRUE
> test_loo_and_waic.R: invokeRestart("muffle_cran_snapshot")52: }, skip = handle_skip, warning = handle_warning, message = handle_message, with_reporter(multi, test_one_file(path, env = the$testing_env, error = handle_error, interrupt = handle_interrupt), error = handle_fatal), shuffle = shuffle)) end_test = function() {
> test_loo_and_waic.R: })53:
> test_loo_and_waic.R: asNamespace("testthat")$queue_task(path, shuffle)45:
> test_loo_and_waic.R: test_code(code = exprs, env = env, reporter = get_reporter() %||% 54: StopReporter$new())(function (path, shuffle)
> test_loo_and_waic.R: {46: asNamespace("testthat")$queue_task(path, shuffle)source_file(path, env = env(env), desc = desc, shuffle = shuffle, })(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) error_call = error_call)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 55: 47: (function (what, args, quote = FALSE, envir = parent.frame()) test_one_file(path, env = the$testing_env, shuffle = shuffle){
> test_loo_and_waic.R: if (!is.list(args)) 48: stop("second argument must be a list")doTryCatch(return(expr), name, parentenv, handler) if (quote)
> test_loo_and_waic.R: args <- lapply(args, enquote)49: .Internal(do.call(what, args, envir))tryCatchOne(expr, names, parentenv, handlers[[1L]])})(base::quote(function (path, shuffle)
> test_loo_and_waic.R: {50: asNamespace("testthat")$queue_task(path, shuffle)tryCatchList(expr, classes, parentenv, handlers)}), 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/RtmporIaEs/callr-fun-13b921dfa2b70"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 57: 51: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"),
> test_loo_and_waic.R: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", compress = FALSE)
> test_loo_and_waic.R: 58: base::withCallingHandlers({52: {with_reporter(multi, test_one_file(path, env = the$testing_env, NULL shuffle = shuffle)) NULL
> test_loo_and_waic.R: }53: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), asNamespace("testthat")$queue_task(path, shuffle) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,
> test_loo_and_waic.R: quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", 54: compress = FALSE)(function (path, shuffle) base::flush(base::stdout()){ base::flush(base::stderr()) asNamespace("testthat")$queue_task(path, shuffle) {})(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) NULL
> test_loo_and_waic.R: NULL55: }(function (what, args, quote = FALSE, envir = parent.frame()) base::invisible(){}, error = function(e) { if (!is.list(args)) { stop("second argument must be a list") callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (quote) err <- callr_data$err args <- lapply(args, enquote) if (FALSE) { .Internal(do.call(what, args, envir)) base::assign(".Traceback", base::.traceback(4), envir = callr_data)})(base::quote(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(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), base::rm("__callr_dump__", envir = .GlobalEnv) quote = base::quote(TRUE)) }
> test_loo_and_waic.R: e <- err$process_call(e)56: e2 <- err$new_error("error in callr subprocess")base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_and_waic.R: 57: class <- base::class
> test_loo_and_waic.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", compress = FALSE)
> test_loo_and_waic.R: 58: base::withCallingHandlers({ class(e2) <- base::c("callr_remote_error", class(e2)) { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { e2 <- err$add_trace_back(e2) NULL NULL cut <- base::which(e2$trace$scope == "global")[1] } if (!base::is.na(cut)) { base::invisible() e2$trace <- e2$trace[-(1:cut), ]}, error = function(e) { } { if (callr_data$has_otel) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` callr_data$otel_span$record_exception(e2) err <- callr_data$err } if (FALSE) { base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", ".error")) }}, interrupt = function(e) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) { utils::dump.frames("__callr_dump__") callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, err <- callr_data$err envir = callr_data) if (FALSE) { base::rm("__callr_dump__", envir = .GlobalEnv) base::assign(".Traceback", base::.traceback(4), envir = callr_data) } utils::dump.frames("__callr_dump__") e <- err$process_call(e) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, e2 <- err$new_error("error in callr subprocess") envir = callr_data) class <- base::class base::rm("__callr_dump__", envir = .GlobalEnv) class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) e <- err$process_call(e) cut <- base::which(e2$trace$scope == "global")[1] e2 <- err$new_error("error in callr subprocess") if (!base::is.na(cut)) { class <- base::class e2$trace <- e2$trace[-(1:cut), ] class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) if (callr_data$has_otel) { cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } callr_data$otel_span$record_exception(e2) 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/RtmporIaEs/callr-rs-result-13b921339d570", } ".error")) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", } ".error"))}, interrupt = function(e) { } {}, callr_message = function(e) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::try({ err <- callr_data$err callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (FALSE) { 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"))) { if (!base::is.na(cut)) { base::invokeRestart("cli_message_handled") e2$trace <- e2$trace[-(1:cut), ] } } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { if (callr_data$has_otel) { base::invokeRestart("muffleMessage") callr_data$otel_span$record_exception(e2) } } }) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", ".error")) }}, callr_message = function(e) { base::try({}) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_and_waic.R: pxlib <- callr_data$pxlib if (base::is.null(e$code)) {59: e$code <- "301"doTryCatch(return(expr), name, parentenv, handler) }
> test_loo_and_waic.R: msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, 60: NULL)))tryCatchOne(expr, names, parentenv, handlers[[1L]]) data <- base::paste0(e$code, " ", base::nchar(msg), "\n",
> test_loo_and_waic.R: msg)61: if (callr_data$has_otel) {tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) 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"))) {
> test_loo_and_waic.R: base::invokeRestart("cli_message_handled")62: }doTryCatch(return(expr), name, parentenv, handler) else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {
> test_loo_and_waic.R: base::invokeRestart("muffleMessage")63: }tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), }) names[nh], parentenv, handlers[[nh]])})
> test_loo_and_waic.R:
> test_loo_and_waic.R: 64: 59: tryCatchList(expr, classes, parentenv, handlers)doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 65: 60: base::tryCatch(base::withCallingHandlers({tryCatchOne(expr, names, parentenv, handlers[[1L]]) {
> test_loo_and_waic.R: NULL61: NULLtryCatchList(expr, names[-nh], parentenv, handlers[-nh]) }
> test_loo_and_waic.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), 62: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, doTryCatch(return(expr), name, parentenv, handler) quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570",
> test_loo_and_waic.R: compress = FALSE)63: base::flush(base::stdout())tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), base::flush(base::stderr()) names[nh], parentenv, handlers[[nh]]) {
> test_loo_and_waic.R: NULL64: NULLtryCatchList(expr, classes, parentenv, handlers) }
> test_loo_and_waic.R: base::invisible()65: }, error = function(e) {base::tryCatch(base::withCallingHandlers({ { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` NULL err <- callr_data$err NULL if (FALSE) { } base::assign(".Traceback", base::.traceback(4), envir = callr_data) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b921dfa2b70"), utils::dump.frames("__callr_dump__") base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,
> test_loo_and_waic.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } compress = FALSE) e <- err$process_call(e) base::flush(base::stdout()) e2 <- err$new_error("error in callr subprocess") base::flush(base::stderr()) class <- base::class { class(e2) <- base::c("callr_remote_error", class(e2)) NULL e2 <- err$add_trace_back(e2) NULL cut <- base::which(e2$trace$scope == "global")[1] } if (!base::is.na(cut)) { base::invisible() e2$trace <- e2$trace[-(1:cut), ]}, error = function(e) { } { if (callr_data$has_otel) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` callr_data$otel_span$record_exception(e2) 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::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", ".error")) }}, interrupt = function(e) { 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)) 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__") e2 <- err$add_trace_back(e2) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { envir = callr_data) callr_data$otel_span$record_exception(e2) 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)) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", ".error")) }}, interrupt = function(e) { { e2 <- err$add_trace_back(e2) callr_data <- base::as.environment("tools:callr")$`__callr_data__` cut <- base::which(e2$trace$scope == "global")[1] err <- callr_data$err if (!base::is.na(cut)) { if (FALSE) { e2$trace <- e2$trace[-(1:cut), ] base::assign(".Traceback", base::.traceback(4), envir = callr_data) } utils::dump.frames("__callr_dump__") if (callr_data$has_otel) { base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, callr_data$otel_span$record_exception(e2) envir = callr_data) } base::rm("__callr_dump__", envir = .GlobalEnv) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", } ".error")) e <- err$process_call(e) } e2 <- err$new_error("error in callr subprocess")}, callr_message = function(e) { class <- base::class base::try({ class(e2) <- base::c("callr_remote_error", class(e2)) callr_data <- base::as.environment("tools:callr")$`__callr_data__` e2 <- err$add_trace_back(e2) pxlib <- callr_data$pxlib cut <- base::which(e2$trace$scope == "global")[1] if (base::is.null(e$code)) { if (!base::is.na(cut)) { e$code <- "301" e2$trace <- e2$trace[-(1:cut), ] } } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, if (callr_data$has_otel) { NULL))) callr_data$otel_span$record_exception(e2) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", } msg) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b921339d570", ".error")) }}, callr_message = function(e) { base::try({ if (callr_data$has_otel) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) pxlib <- callr_data$pxlib } if (base::is.null(e$code)) { pxlib$write_fd(3L, data) e$code <- "301" 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") } } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, }) NULL)))}), error = function(e) { data <- base::paste0(e$code, " ", base::nchar(msg), "\n", { msg) NULL if (callr_data$has_otel) { NULL callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } } if (FALSE) { pxlib$write_fd(3L, data) base::try(base::stop(e)) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { } base::invokeRestart("cli_message_handled") if (FALSE) { } base::q(save = "no", status = 1) else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { } base::invokeRestart("muffleMessage") base::invisible() }}, interrupt = function(e) { }) {}), error = function(e) { NULL { NULL NULL } NULL if (FALSE) { } base::q(save = "no", status = 1) if (FALSE) { } base::try(base::stop(e)) base::invisible() }}) if (FALSE) {
> test_loo_and_waic.R: base::q(save = "no", status = 1)An irrecoverable exception occurred. R is aborting now ...
> test_loo_and_waic.R: } 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)
> test_loo_predictive_metric.R: Traceback:
> test_loo_predictive_metric.R: if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") 1: outer(X, Y) LONG <- 75L
> test_loo_predictive_metric.R: sm <- strsplit(conditionMessage(e), "\n")[[1L]] 2: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")-theta %o% x if (is.na(w))
> test_loo_predictive_metric.R: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 3: type = "b")posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE) if (w > LONG)
> test_loo_predictive_metric.R: prefix <- paste0(prefix, "\n ") 4: }psis_smooth_tail(lw_tail, cutoff) else prefix <- "Error : "
> test_loo_predictive_metric.R: msg <- paste0(prefix, conditionMessage(e), "\n") 5: .Internal(seterrmessage(msg[1L]))is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]) if (!silent && isTRUE(getOption("show.error.messages"))) {
> test_loo_predictive_metric.R: cat(msg, file = outFile) 6: .Internal(printDeferredWarnings())FUN(X[[i]], ...) }
> test_loo_predictive_metric.R: invisible(structure(msg, class = "try-error", condition = e)) 7: })lapply(X = S, FUN = FUN, ...)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 12: 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 13: 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 14: 10: FUN(X[[i]], ...)tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 15: 11: lapply(seq_len(cores), inner.do)tryCatch(expr, error = function(e) {
> test_loo_predictive_metric.R: call <- conditionCall(e)16: if (!is.null(call)) {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: if (identical(call[[1L]], quote(doTryCatch))) importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores, call <- sys.call(-4L) method = "psis") dcall <- deparse(call, nlines = 1L)
> test_loo_predictive_metric.R: prefix <- paste("Error in", dcall, ": ")19: LONG <- 75Lpsis.matrix(-LL, r_eff = r_eff, cores = 2) sm <- strsplit(conditionMessage(e), "\n")[[1L]]
> test_loo_predictive_metric.R: 20: psis(-LL, r_eff = r_eff, cores = 2) w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
> test_loo_predictive_metric.R: if (is.na(w)) 21: w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], eval(code, test_env) type = "b")
> test_loo_predictive_metric.R: if (w > LONG) 22: prefix <- paste0(prefix, "\n ")eval(code, test_env)
> test_loo_predictive_metric.R: }
> 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 prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) 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.")) } .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
> test_loo_predictive_metric.R: 12: }, snapshot_on_cran = function(cnd) {try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 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)
> test_loo_predictive_metric.R: 13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
> test_loo_predictive_metric.R: 14: FUN(X[[i]], ...) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }
> test_loo_predictive_metric.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {15: if (on_cran()) {lapply(seq_len(cores), inner.do) skip(paste0("{", e$package, "} is not installed."))
> test_loo_predictive_metric.R: }16: }, snapshot_on_cran = function(cnd) {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, 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: 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: doWithOneRestart(return(expr), restart)
> test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]])
> test_loo_predictive_metric.R: 30: withRestarts(tryCatch(withCallingHandlers({psis(-LL, r_eff = r_eff, cores = 2) eval(code, test_env)
> test_loo_predictive_metric.R: new_expectations <- the$test_expectations > starting_expectations21: if (snapshot_skipped) {eval(code, test_env) skip("On CRAN")
> test_loo_predictive_metric.R: }22: else if (!new_expectations && skip_on_empty) {eval(code, test_env) skip_empty()
> test_loo_predictive_metric.R: }23: }, expectation = handle_expectation, packageNotFoundError = function(e) {withCallingHandlers({ if (on_cran()) { eval(code, test_env) skip(paste0("{", e$package, "} is not installed.")) new_expectations <- the$test_expectations > starting_expectations } if (snapshot_skipped) {}, snapshot_on_cran = function(cnd) { skip("On CRAN") snapshot_skipped <<- TRUE } invokeRestart("muffle_cran_snapshot") else if (!new_expectations && skip_on_empty) {}, skip = handle_skip, warning = handle_warning, message = handle_message, skip_empty() error = handle_error, interrupt = handle_interrupt), error = handle_fatal), } end_test = function() {}, expectation = handle_expectation, packageNotFoundError = function(e) { }) if (on_cran()) {
> test_loo_predictive_metric.R: skip(paste0("{", e$package, "} is not installed."))31: }test_code(code = exprs, env = env, reporter = get_reporter() %||% }, snapshot_on_cran = function(cnd) { StopReporter$new()) snapshot_skipped <<- TRUE
> test_loo_predictive_metric.R: invokeRestart("muffle_cran_snapshot")32: }, skip = handle_skip, warning = handle_warning, message = handle_message, source_file(path, env = env(env), desc = desc, shuffle = shuffle, error = handle_error, interrupt = handle_interrupt) error_call = error_call)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 24: 33: doTryCatch(return(expr), name, parentenv, handler)test_one_file(path, env = the$testing_env, shuffle = shuffle)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 25: 34: tryCatchOne(expr, names, parentenv, handlers[[1L]])doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 26: 35: tryCatchList(expr, classes, parentenv, handlers)tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 27: 36: tryCatch(withCallingHandlers({tryCatchList(expr, classes, parentenv, handlers) eval(code, test_env)
> test_loo_predictive_metric.R: new_expectations <- the$test_expectations > starting_expectations37: if (snapshot_skipped) {tryCatch(code, testthat_abort_reporter = function(cnd) { skip("On CRAN") cat(conditionMessage(cnd), "\n") } NULL else if (!new_expectations && skip_on_empty) {}) skip_empty()
> test_loo_predictive_metric.R: }38: }, expectation = handle_expectation, packageNotFoundError = function(e) {with_reporter(multi, test_one_file(path, env = the$testing_env, if (on_cran()) { shuffle = shuffle)) skip(paste0("{", e$package, "} is not installed."))
> test_loo_predictive_metric.R: }}, 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)39:
> test_loo_predictive_metric.R: asNamespace("testthat")$queue_task(path, shuffle)28:
> test_loo_predictive_metric.R: doWithOneRestart(return(expr), restart)40:
> test_loo_predictive_metric.R: (function (path, shuffle) 29: {withOneRestart(expr, restarts[[1L]]) asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_predictive_metric.R: })(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE))30:
> test_loo_predictive_metric.R: withRestarts(tryCatch(withCallingHandlers({41: eval(code, test_env)(function (what, args, quote = FALSE, envir = parent.frame()) new_expectations <- the$test_expectations > starting_expectations{ if (snapshot_skipped) { if (!is.list(args)) skip("On CRAN") stop("second argument must be a list") } if (quote) else if (!new_expectations && skip_on_empty) { args <- lapply(args, enquote) skip_empty() .Internal(do.call(what, args, envir)) }})(base::quote(function (path, shuffle) }, expectation = handle_expectation, packageNotFoundError = function(e) {{ asNamespace("testthat")$queue_task(path, shuffle)}), base::quote(list("test_loo_predictive_metric.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE))
> test_loo_predictive_metric.R: 42: if (on_cran()) {base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE) 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: 43: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", }) compress = FALSE)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 31: 44: test_code(code = exprs, env = env, reporter = get_reporter() %||% base::withCallingHandlers({ StopReporter$new()) {
> test_loo_predictive_metric.R: NULL32: NULLsource_file(path, env = env(env), desc = desc, shuffle = shuffle, } error_call = error_call) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"),
> test_loo_predictive_metric.R: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 33: quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", test_one_file(path, env = the$testing_env, shuffle = shuffle) compress = FALSE)
> test_loo_predictive_metric.R: base::flush(base::stdout())34: base::flush(base::stderr())doTryCatch(return(expr), name, parentenv, handler) {
> test_loo_predictive_metric.R: NULL35: NULLtryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: }
> test_loo_predictive_metric.R: 36: tryCatchList(expr, classes, parentenv, handlers) base::invisible()
> test_loo_predictive_metric.R: }, error = function(e) {37: {tryCatch(code, testthat_abort_reporter = function(cnd) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` cat(conditionMessage(cnd), "\n") err <- callr_data$err NULL if (FALSE) {}) base::assign(".Traceback", base::.traceback(4), envir = callr_data)
> test_loo_predictive_metric.R: utils::dump.frames("__callr_dump__")38: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, with_reporter(multi, test_one_file(path, env = the$testing_env, envir = callr_data) shuffle = shuffle)) base::rm("__callr_dump__", envir = .GlobalEnv)
> test_loo_predictive_metric.R: }39: e <- err$process_call(e)asNamespace("testthat")$queue_task(path, shuffle) 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)
> 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/RtmporIaEs/callr-rs-result-13b929c5cdc3", ".error")) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__`(function (what, args, quote = FALSE, envir = parent.frame()) err <- callr_data$err{ if (FALSE) { if (!is.list(args)) base::assign(".Traceback", base::.traceback(4), envir = callr_data) stop("second argument must be a list") utils::dump.frames("__callr_dump__") if (quote) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, args <- lapply(args, enquote) envir = callr_data) .Internal(do.call(what, args, envir)) base::rm("__callr_dump__", envir = .GlobalEnv)})(base::quote(function (path, shuffle) }{ e <- err$process_call(e) asNamespace("testthat")$queue_task(path, shuffle) e2 <- err$new_error("error in callr subprocess")}), base::quote(list("test_loo_predictive_metric.R", FALSE)), class <- base::class envir = base::quote(<environment>), quote = base::quote(TRUE)) class(e2) <- base::c("callr_remote_error", class(e2))
> test_loo_predictive_metric.R: e2 <- err$add_trace_back(e2)42: cut <- base::which(e2$trace$scope == "global")[1]base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_predictive_metric.R: 43: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", compress = FALSE)
> test_loo_predictive_metric.R: 44: base::withCallingHandlers({ { base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", compress = FALSE) base::flush(base::stdout()) pxlib <- callr_data$pxlib base::flush(base::stderr()) if (base::is.null(e$code)) { { e$code <- "301" NULL } NULL msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, } NULL))) base::invisible() data <- base::paste0(e$code, " ", base::nchar(msg), "\n", }, error = function(e) { msg) { if (callr_data$has_otel) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` 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") } err <- callr_data$err else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { if (FALSE) { base::invokeRestart("muffleMessage") base::assign(".Traceback", base::.traceback(4), envir = callr_data) } utils::dump.frames("__callr_dump__") }) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, }) envir = callr_data)
> test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv)45: }doTryCatch(return(expr), name, parentenv, handler) e <- err$process_call(e)
> test_loo_predictive_metric.R: e2 <- err$new_error("error in callr subprocess")46: class <- base::classtryCatchOne(expr, names, parentenv, handlers[[1L]]) 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), ] }
> test_loo_predictive_metric.R: if (callr_data$has_otel) {47: callr_data$otel_span$record_exception(e2)tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) }
> test_loo_predictive_metric.R: base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", 48: ".error"))doTryCatch(return(expr), name, parentenv, handler) }
> test_loo_predictive_metric.R: }, interrupt = function(e) {49: {tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), callr_data <- base::as.environment("tools:callr")$`__callr_data__` names[nh], parentenv, handlers[[nh]]) err <- callr_data$err
> test_loo_predictive_metric.R: if (FALSE) {50: base::assign(".Traceback", base::.traceback(4), envir = callr_data)tryCatchList(expr, classes, parentenv, handlers) utils::dump.frames("__callr_dump__")
> test_loo_predictive_metric.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, 51: envir = callr_data)base::tryCatch(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/RtmporIaEs/callr-fun-13b923f9fa3f7"), class(e2) <- base::c("callr_remote_error", class(e2)) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, e2 <- err$add_trace_back(e2) quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", cut <- base::which(e2$trace$scope == "global")[1] compress = FALSE) if (!base::is.na(cut)) { base::flush(base::stdout()) e2$trace <- e2$trace[-(1:cut), ] base::flush(base::stderr()) } { if (callr_data$has_otel) { NULL callr_data$otel_span$record_exception(e2) NULL } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", ".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: e$code <- "301" base::invisible() } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg)}, 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) 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"))) { 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") base::invokeRestart("muffleMessage") } })})
> test_loo_predictive_metric.R: 45: doTryCatch(return(expr), name, parentenv, handler) 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), ] }
> 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]) 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/RtmporIaEs/callr-rs-result-13b929c5cdc3", ".error"))
> test_loo_predictive_metric.R: }48: }, interrupt = function(e) {doTryCatch(return(expr), name, parentenv, handler) {
> test_loo_predictive_metric.R: callr_data <- base::as.environment("tools:callr")$`__callr_data__`49: err <- callr_data$errtryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), if (FALSE) { names[nh], parentenv, handlers[[nh]]) base::assign(".Traceback", base::.traceback(4), envir = callr_data)
> test_loo_predictive_metric.R: utils::dump.frames("__callr_dump__")50: 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)51: }base::tryCatch(base::withCallingHandlers({ e <- err$process_call(e) { e2 <- err$new_error("error in callr subprocess") NULL class <- base::class 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::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmporIaEs/callr-fun-13b923f9fa3f7"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) } { if (callr_data$has_otel) { NULL callr_data$otel_span$record_exception(e2) NULL } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", base::invisible() ".error"))}, error = function(e) { } {}, callr_message = function(e) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::try({ err <- callr_data$err callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (FALSE) { 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"))) { if (!base::is.na(cut)) { base::invokeRestart("cli_message_handled") e2$trace <- e2$trace[-(1:cut), ] } } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { if (callr_data$has_otel) { base::invokeRestart("muffleMessage") callr_data$otel_span$record_exception(e2) } } }) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", }), error = function(e) { ".error")) { } NULL}, interrupt = function(e) { NULL { } callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (FALSE) { err <- callr_data$err base::try(base::stop(e)) if (FALSE) { } base::assign(".Traceback", base::.traceback(4), envir = callr_data) if (FALSE) { utils::dump.frames("__callr_dump__") base::q(save = "no", status = 1) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, } envir = callr_data) base::invisible() base::rm("__callr_dump__", envir = .GlobalEnv)}, interrupt = function(e) { } { e <- err$process_call(e) NULL e2 <- err$new_error("error in callr subprocess") NULL class <- base::class } class(e2) <- base::c("callr_remote_error", class(e2)) if (FALSE) { e2 <- err$add_trace_back(e2) base::q(save = "no", status = 1) cut <- base::which(e2$trace$scope == "global")[1] } if (!base::is.na(cut)) { base::invisible() e2$trace <- e2$trace[-(1:cut), ]}) }
> test_loo_predictive_metric.R: if (callr_data$has_otel) {An irrecoverable exception occurred. R is aborting now ...
> test_loo_predictive_metric.R: callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmporIaEs/callr-rs-result-13b929c5cdc3", ".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 }
> test_loo_predictive_metric.R: 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