CRAN Package Check Results for Package loo

Last updated on 2026-07-01 06:02:08 CEST.

Check Details

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: 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: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 10: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.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_and_waic.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE) > test_loo_and_waic.R: 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: 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, method = is_method) > test_loo_and_waic.R: 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: 21: withCallingHandlers(expr, warning = function(w) if (inherits(w, classes)) tryInvokeRestart("muffleWarning")) > test_loo_and_waic.R: 22: suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) > 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: > test_loo_and_waic.R: 23: 8: eval(code, test_env)doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: > test_loo_and_waic.R: 24: 9: eval(code, test_env) > test_loo_and_waic.R: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 10: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.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_and_waic.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE) > test_loo_and_waic.R: 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: > test_loo_and_waic.R: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[, 25: i], tail_len_i = tail_len[i]))withCallingHandlers({ > 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, eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } method = is_method) > test_loo_and_waic.R: 19: loo.array(LLarr, r_eff = r_eff_arr, cores = 2) > test_loo_and_waic.R: 20: 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."))loo(LLarr, r_eff = r_eff_arr, cores = 2) > test_loo_and_waic.R: 21: withCallingHandlers(expr, warning = function(w) if (inherits(w, classes)) tryInvokeRestart("muffleWarning")) > test_loo_and_waic.R: 22: }}, 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)suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) > test_loo_and_waic.R: 23: eval(code, test_env) > test_loo_and_waic.R: 24: > test_loo_and_waic.R: 26: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 27: eval(code, test_env) > test_loo_and_waic.R: 25: withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectationstryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 28: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: 29: if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }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) {}, expectation = handle_expectation, packageNotFoundError = function(e) { 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, 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_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: 32: > test_loo_and_waic.R: 26: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 27: tryCatchOne(expr, names, parentenv, handlers[[1L]])withRestarts(tryCatch(withCallingHandlers({ > test_loo_and_waic.R: 28: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") }29: tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { 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.")) } 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() { })}, 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_and_waic.R: 30: doWithOneRestart(return(expr), restart) > test_loo_and_waic.R: > 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", 31: withOneRestart(expr, restarts[[1L]]) > 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() { loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) expect_equal(loo1$estimates, loo2$estimates) }) }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) > test_loo_and_waic.R: 35: eval(code, test_env) > test_loo_and_waic.R: 36: }}, 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), eval(code, test_env) > test_loo_and_waic.R: 37: withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations end_test = function() { if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { }) > test_loo_and_waic.R: 33: test_code(code, parent.frame()) > test_loo_and_waic.R: 34: if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUEtest_that("loo with cores=1 and cores=2 gives same results", invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt) > test_loo_and_waic.R: { 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: 36: eval(code, test_env) > test_loo_and_waic.R: 37: 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_and_waic.R: 38: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 39: 38: doTryCatch(return(expr), name, parentenv, handler)tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 40: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: 41: tryCatch(withCallingHandlers({ eval(code, test_env) > test_loo_and_waic.R: 39: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 40: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) {41: tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) } skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) {}, 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_and_waic.R: 42: doWithOneRestart(return(expr), restart) > test_loo_and_waic.R: 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_and_waic.R: 43: withOneRestart(expr, restarts[[1L]]) > test_loo_and_waic.R: 44: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) {42: doWithOneRestart(return(expr), restart) > test_loo_and_waic.R: 43: withOneRestart(expr, restarts[[1L]]) > test_loo_and_waic.R: 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), end_test = function() { }) > test_loo_and_waic.R: 45: test_code(code = exprs, env = env, reporter = get_reporter() %||% StopReporter$new()) > 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: 47: test_one_file(path, env = the$testing_env, shuffle = shuffle) > test_loo_and_waic.R: 44: withRestarts(tryCatch(withCallingHandlers({48: eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) {doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 49: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 50: tryCatchList(expr, classes, parentenv, handlers) skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { > test_loo_and_waic.R: 51: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL}) if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE > test_loo_and_waic.R: 52: with_reporter(multi, test_one_file(path, env = the$testing_env, shuffle = shuffle)) > test_loo_and_waic.R: 53: 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_and_waic.R: asNamespace("testthat")$queue_task(path, shuffle) > test_loo_and_waic.R: 54: (function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) > test_loo_and_waic.R: 55: (function (what, args, quote = FALSE, envir = parent.frame()) 45: test_code(code = exprs, env = env, reporter = get_reporter() %||% StopReporter$new()) > test_loo_and_waic.R: 46: { if (!is.list(args)) stop("second argument must be a list") if (quote) args <- lapply(args, enquote)source_file(path, env = env(env), desc = desc, shuffle = shuffle, error_call = error_call) > test_loo_and_waic.R: 47: test_one_file(path, env = the$testing_env, shuffle = shuffle) .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), > test_loo_and_waic.R: 48: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 49: tryCatchOne(expr, names, parentenv, handlers[[1L]]) quote = base::quote(TRUE)) > test_loo_and_waic.R: 56: base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE) > test_loo_and_waic.R: 57: > test_loo_and_waic.R: 50: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: 51: tryCatch(code, testthat_abort_reporter = function(cnd) {base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) > test_loo_and_waic.R: 58: cat(conditionMessage(cnd), "\n") NULL}) > test_loo_and_waic.R: 52: with_reporter(multi, test_one_file(path, env = the$testing_env, base::withCallingHandlers({ shuffle = shuffle)) > test_loo_and_waic.R: 53: asNamespace("testthat")$queue_task(path, shuffle) > test_loo_and_waic.R: 54: (function (path, shuffle) { { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_and_waic.R"), base::quote(FALSE)) > test_loo_and_waic.R: 55: (function (what, args, quote = FALSE, envir = parent.frame()) { if (!is.list(args)) stop("second argument must be a list") if (quote) quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL args <- lapply(args, enquote) .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE)) > test_loo_and_waic.R: 56: NULLbase::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE) > test_loo_and_waic.R: 57: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) > test_loo_and_waic.R: 58: base::withCallingHandlers({ { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) 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) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } } 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] 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) if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { 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)) 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) { } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) }}, interrupt = function(e) { { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) }}, interrupt = function(e) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { { > test_loo_and_waic.R: base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") 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) class <- base::class base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") 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), ] } 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)) { 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/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", 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/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) }}, callr_message = function(e) { ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } 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 <- 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)) 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) } 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"))) { 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_and_waic.R: base::invokeRestart("muffleMessage") } })}) > test_loo_and_waic.R: 59: 59: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 60: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 61: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 60: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_and_waic.R: 61: tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) > test_loo_and_waic.R: 62: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 63: tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) > test_loo_and_waic.R: 62: doTryCatch(return(expr), name, parentenv, handler) > test_loo_and_waic.R: 63: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]]) > test_loo_and_waic.R: 64: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]]) > test_loo_and_waic.R: 64: tryCatchList(expr, classes, parentenv, handlers) > test_loo_and_waic.R: 65: base::tryCatch(base::withCallingHandlers({ { NULL NULL }65: base::tryCatch(base::withCallingHandlers({ { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1605a66ac"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err { NULL NULL } base::invisible()}, error = function(e) { 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) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) } 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), ] utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } } 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/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) 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] }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } 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) base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", > test_loo_and_waic.R: ".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__") e2 <- err$new_error("error in callr subprocess") 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 <- 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)) { 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) } 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/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b14f0ad79f", ".error")) }}, callr_message = function(e) { base::try({ pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) 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) 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"))) { 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 base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { { NULL 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() NULL } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}) > test_loo_and_waic.R: An irrecoverable exception occurred. R is aborting now ... > test_loo_and_waic.R: }) > 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: > 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: 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: 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: psis(-LL, r_eff = r_eff, cores = 2) > test_loo_predictive_metric.R: 21: eval(code, test_env) > test_loo_predictive_metric.R: 22: 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: eval(code, test_env) > test_loo_predictive_metric.R: 23: withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations 7: lapply(X = S, FUN = FUN, ...) > test_loo_predictive_metric.R: 8: doTryCatch(return(expr), name, parentenv, handler) > test_loo_predictive_metric.R: if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() } 9: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_predictive_metric.R: 10: tryCatchList(expr, classes, parentenv, handlers) > test_loo_predictive_metric.R: 11: }, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUEtryCatch(expr, error = function(e) { > test_loo_predictive_metric.R: call <- conditionCall(e) if (!is.null(call)) { invokeRestart("muffle_cran_snapshot") if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L)}, 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: 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)) 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) { w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() } 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: }, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUEtry(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: 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)FUN(X[[i]], ...) > test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]]) > test_loo_predictive_metric.R: > 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: 30: withRestarts(tryCatch(withCallingHandlers({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) {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") 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: 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: 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, 22: eval(code, test_env) > test_loo_predictive_metric.R: 23: withCallingHandlers({ eval(code, test_env) 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() %||% new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() StopReporter$new()) > test_loo_predictive_metric.R: 32: source_file(path, env = env(env), desc = desc, shuffle = shuffle, error_call = error_call) > test_loo_predictive_metric.R: }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) {33: test_one_file(path, env = the$testing_env, shuffle = shuffle) > test_loo_predictive_metric.R: 34: doTryCatch(return(expr), name, parentenv, handler) > test_loo_predictive_metric.R: 35: snapshot_skipped <<- TRUEtryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_predictive_metric.R: 36: tryCatchList(expr, classes, parentenv, handlers) 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: > test_loo_predictive_metric.R: 37: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})doTryCatch(return(expr), name, parentenv, handler) > test_loo_predictive_metric.R: 25: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_predictive_metric.R: > test_loo_predictive_metric.R: 38: with_reporter(multi, test_one_file(path, env = the$testing_env, shuffle = shuffle)) > test_loo_predictive_metric.R: 39: 26: tryCatchList(expr, classes, parentenv, handlers) > test_loo_predictive_metric.R: 27: tryCatch(withCallingHandlers({ eval(code, test_env)asNamespace("testthat")$queue_task(path, shuffle) > test_loo_predictive_metric.R: 40: (function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) {})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE)) > test_loo_predictive_metric.R: 41: (function (what, args, quote = FALSE, envir = parent.frame()) { if (!is.list(args)) skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) } stop("second argument must be a list")}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot") if (quote) args <- lapply(args, enquote) .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle)}, 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: }), base::quote(list("test_loo_predictive_metric.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE)) > test_loo_predictive_metric.R: 42: base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, 29: withOneRestart(expr, restarts[[1L]]) > test_loo_predictive_metric.R: 30: withRestarts(tryCatch(withCallingHandlers({ quote = TRUE) > test_loo_predictive_metric.R: 43: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", skip_empty() }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { compress = FALSE) > test_loo_predictive_metric.R: 44: base::withCallingHandlers({ { NULL NULL skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { 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: 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)31: > test_loo_predictive_metric.R: test_code(code = exprs, env = env, reporter = get_reporter() %||% utils::dump.frames("__callr_dump__") StopReporter$new()) > test_loo_predictive_metric.R: 32: source_file(path, env = env(env), desc = desc, shuffle = shuffle, base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, error_call = error_call) envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) > test_loo_predictive_metric.R: 33: test_one_file(path, env = the$testing_env, shuffle = shuffle) > test_loo_predictive_metric.R: 34: 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)doTryCatch(return(expr), name, parentenv, handler) > test_loo_predictive_metric.R: 35: tryCatchOne(expr, names, parentenv, handlers[[1L]]) > test_loo_predictive_metric.R: 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/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", ".error")) }}, interrupt = 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__`, }) > test_loo_predictive_metric.R: 38: with_reporter(multi, test_one_file(path, env = the$testing_env, shuffle = shuffle)) envir = callr_data) > test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv)39: }asNamespace("testthat")$queue_task(path, shuffle) e <- err$process_call(e) > test_loo_predictive_metric.R: e2 <- err$new_error("error in callr subprocess")40: class <- base::class(function (path, shuffle) class(e2) <- base::c("callr_remote_error", class(e2)){ e2 <- err$add_trace_back(e2) asNamespace("testthat")$queue_task(path, shuffle) cut <- base::which(e2$trace$scope == "global")[1]})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE)) if (!base::is.na(cut)) { > test_loo_predictive_metric.R: e2$trace <- e2$trace[-(1:cut), ]41: }(function (what, args, quote = FALSE, envir = parent.frame()) if (callr_data$has_otel) {{ callr_data$otel_span$record_exception(e2) if (!is.list(args)) } stop("second argument must be a list") base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", ".error")) }}, callr_message = function(e) { base::try({ if (quote) callr_data <- base::as.environment("tools:callr")$`__callr_data__` args <- lapply(args, enquote) .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle) pxlib <- callr_data$pxlib}), base::quote(list("test_loo_predictive_metric.R", FALSE)), if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) envir = base::quote(<environment>), quote = base::quote(TRUE)) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", > test_loo_predictive_metric.R: 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") }42: else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), base::invokeRestart("muffleMessage") base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, } quote = TRUE) }) > test_loo_predictive_metric.R: })43: > test_loo_predictive_metric.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), 45: base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, doTryCatch(return(expr), name, parentenv, handler) quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", > test_loo_predictive_metric.R: compress = FALSE)46: > test_loo_predictive_metric.R: tryCatchOne(expr, names, parentenv, handlers[[1L]])44: > test_loo_predictive_metric.R: base::withCallingHandlers({ { NULL NULL }47: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, > test_loo_predictive_metric.R: quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::invisible()48: }, error = 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) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") > test_loo_predictive_metric.R: class <- base::class51: 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] NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, if (!base::is.na(cut)) { quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) 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/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", NULL ".error")) NULL } }}, interrupt = function(e) { base::invisible() {}, error = function(e) { callr_data <- base::as.environment("tools:callr")$`__callr_data__` { err <- callr_data$err callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (FALSE) { err <- callr_data$err base::assign(".Traceback", base::.traceback(4), envir = callr_data) if (FALSE) { utils::dump.frames("__callr_dump__") base::assign(".Traceback", base::.traceback(4), envir = callr_data) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, utils::dump.frames("__callr_dump__") envir = callr_data) base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, base::rm("__callr_dump__", envir = .GlobalEnv) envir = callr_data) } base::rm("__callr_dump__", envir = .GlobalEnv) e <- err$process_call(e) } e2 <- err$new_error("error in callr subprocess") e <- err$process_call(e) class <- base::class e2 <- err$new_error("error in callr subprocess") > test_loo_predictive_metric.R: 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/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` class <- base::class 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) { class(e2) <- base::c("callr_remote_error", class(e2)) callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) e2 <- err$add_trace_back(e2) } cut <- base::which(e2$trace$scope == "global")[1] pxlib$write_fd(3L, data) if (!base::is.na(cut)) { if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { e2$trace <- e2$trace[-(1:cut), ] base::invokeRestart("cli_message_handled") } } if (callr_data$has_otel) { else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { callr_data$otel_span$record_exception(e2) base::invokeRestart("muffleMessage") } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", }) ".error"))}) } > test_loo_predictive_metric.R: }, interrupt = function(e) {45: {doTryCatch(return(expr), name, parentenv, handler) callr_data <- base::as.environment("tools:callr")$`__callr_data__` > test_loo_predictive_metric.R: err <- callr_data$err46: 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__")47: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) envir = callr_data) > test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv)48: }doTryCatch(return(expr), name, parentenv, handler) e <- err$process_call(e) > test_loo_predictive_metric.R: e2 <- err$new_error("error in callr subprocess")49: class <- base::classtryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]]) > test_loo_predictive_metric.R: 50: tryCatchList(expr, classes, parentenv, handlers) class(e2) <- base::c("callr_remote_error", class(e2)) > test_loo_predictive_metric.R: e2 <- err$add_trace_back(e2)51: cut <- base::which(e2$trace$scope == "global")[1]base::tryCatch(base::withCallingHandlers({ { NULL NULL } if (!base::is.na(cut)) { base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-fun-155b1f2f9dc3"), e2$trace <- e2$trace[-(1:cut), ] base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, } quote = TRUE), file = "/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::invisible() if (callr_data$has_otel) {}, error = function(e) { callr_data$otel_span$record_exception(e2) { } callr_data <- base::as.environment("tools:callr")$`__callr_data__` base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", err <- callr_data$err ".error")) if (FALSE) { } base::assign(".Traceback", base::.traceback(4), envir = callr_data)}, callr_message = function(e) { utils::dump.frames("__callr_dump__") base::try({ base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, callr_data <- base::as.environment("tools:callr")$`__callr_data__` envir = callr_data) pxlib <- callr_data$pxlib base::rm("__callr_dump__", envir = .GlobalEnv) if (base::is.null(e$code)) { } e$code <- "301" e <- err$process_call(e) } e2 <- err$new_error("error in callr subprocess") msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, class <- base::class NULL))) class(e2) <- base::c("callr_remote_error", class(e2)) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", e2 <- err$add_trace_back(e2) msg) cut <- base::which(e2$trace$scope == "global")[1] if (callr_data$has_otel) { if (!base::is.na(cut)) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) e2$trace <- e2$trace[-(1:cut), ] } } pxlib$write_fd(3L, data) if (callr_data$has_otel) { if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { callr_data$otel_span$record_exception(e2) base::invokeRestart("cli_message_handled") } } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL ".error")) NULL } }}, interrupt = function(e) { if (FALSE) { { base::try(base::stop(e)) 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__`, }, interrupt = function(e) { envir = callr_data) { base::rm("__callr_dump__", envir = .GlobalEnv) NULL } NULL e <- err$process_call(e) } e2 <- err$new_error("error in callr subprocess") if (FALSE) { class <- base::class base::q(save = "no", status = 1) class(e2) <- base::c("callr_remote_error", class(e2)) } e2 <- err$add_trace_back(e2) base::invisible() cut <- base::which(e2$trace$scope == "global")[1]}) if (!base::is.na(cut)) { > test_loo_predictive_metric.R: e2$trace <- e2$trace[-(1:cut), ]An irrecoverable exception occurred. R is aborting now ... > test_loo_predictive_metric.R: } 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/Rtmpuxk2Mr/callr-rs-result-155b17f1e74fe", ".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") } > test_loo_predictive_metric.R: 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