Last updated on 2026-07-21 02:50:36 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 2.10.0 | 5.88 | 142.77 | 148.65 | OK | |
| r-devel-linux-x86_64-debian-gcc | 2.10.0 | 4.40 | 97.66 | 102.06 | OK | |
| r-devel-linux-x86_64-fedora-clang | 2.10.0 | 10.00 | 223.42 | 233.42 | OK | |
| r-devel-linux-x86_64-fedora-gcc | 2.10.0 | 104.38 | OK | |||
| r-devel-windows-x86_64 | 2.10.0 | 10.00 | 140.00 | 150.00 | OK | |
| r-patched-linux-x86_64 | 2.10.0 | 8.11 | 132.98 | 141.09 | OK | |
| r-release-linux-x86_64 | 2.10.0 | 6.54 | 134.06 | 140.60 | OK | |
| r-release-macos-arm64 | 2.10.0 | 2.00 | 33.00 | 35.00 | OK | |
| r-release-macos-x86_64 | 2.10.0 | 5.00 | 165.00 | 170.00 | OK | |
| r-release-windows-x86_64 | 2.10.0 | 11.00 | 147.00 | 158.00 | OK | |
| r-oldrel-macos-arm64 | 2.10.0 | 2.00 | 38.00 | 40.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 | 178.00 | 191.00 | OK |
Version: 2.10.0
Check: tests
Result: ERROR
Running ‘testthat.R’ [14s/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:
> 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, ...)outer(X, Y)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 8: doTryCatch(return(expr), name, parentenv, handler) 2:
> test_loo_and_waic.R: -theta %o% x
> test_loo_and_waic.R: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE) 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)
> test_loo_and_waic.R: if (!is.null(call)) { 4: if (identical(call[[1L]], quote(doTryCatch))) psis_smooth_tail(lw_tail, cutoff) 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]] 5: 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 : "is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i]) msg <- paste0(prefix, conditionMessage(e), "\n")
> test_loo_and_waic.R: .Internal(seterrmessage(msg[1L])) 6: if (!silent && isTRUE(getOption("show.error.messages"))) {FUN(X[[i]], ...) cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))
> test_loo_and_waic.R: }) 7:
> test_loo_and_waic.R: lapply(X = S, FUN = FUN, ...)12:
> test_loo_and_waic.R: try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 8:
> test_loo_and_waic.R: doTryCatch(return(expr), name, parentenv, handler)13:
> test_loo_and_waic.R: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_and_waic.R: 10:
> test_loo_and_waic.R: tryCatchList(expr, classes, parentenv, handlers)14: FUN(X[[i]], ...)
> test_loo_and_waic.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_and_waic.R: 11: tryCatch(expr, error = function(e) { call <- conditionCall(e)
> 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: if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L)do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, prefix <- paste("Error in", dcall, ": ") method = method) LONG <- 75L
> test_loo_and_waic.R: sm <- strsplit(conditionMessage(e), "\n")[[1L]]18: w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, if (is.na(w)) method = is_method) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],
> test_loo_and_waic.R: type = "b")19: if (w > LONG) loo.array(LLarr, r_eff = r_eff_arr, cores = 2) prefix <- paste0(prefix, "\n ")
> test_loo_and_waic.R: 20: }loo(LLarr, r_eff = r_eff_arr, cores = 2) else prefix <- "Error : "
> test_loo_and_waic.R: msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile)21: .Internal(printDeferredWarnings())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: invisible(structure(msg, class = "try-error", condition = e))})
> test_loo_and_waic.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)23:
> test_loo_and_waic.R: eval(code, test_env)
> test_loo_and_waic.R: 24: eval(code, test_env)
> test_loo_and_waic.R: 13: 25: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))withCallingHandlers({
> test_loo_and_waic.R: eval(code, test_env)14: new_expectations <- the$test_expectations > starting_expectationsFUN(X[[i]], ...) if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) {
> test_loo_and_waic.R: 15: lapply(seq_len(cores), inner.do)
> test_loo_and_waic.R: 16: skip_empty()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: }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE17: 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: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 27: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_and_waic.R: 28: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 29: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, tryCatch(withCallingHandlers({ method = method) eval(code, test_env)
> test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations18: if (snapshot_skipped) {importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, skip("On CRAN") method = is_method) }
> test_loo_and_waic.R: else if (!new_expectations && skip_on_empty) {19: skip_empty()loo.array(LLarr, r_eff = r_eff_arr, cores = 2) }
> test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {20: if (on_cran()) {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")) skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE
> test_loo_and_waic.R: 22: suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))
> test_loo_and_waic.R: 23: invokeRestart("muffle_cran_snapshot")eval(code, test_env)}, skip = handle_skip, warning = handle_warning, message = handle_message,
> test_loo_and_waic.R: error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 30: doWithOneRestart(return(expr), restart)24:
> test_loo_and_waic.R: eval(code, test_env)
> test_loo_and_waic.R: 25: withCallingHandlers({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") 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) { else if (!new_expectations && skip_on_empty) { if (on_cran()) { 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(paste0("{", e$package, "} is not installed."))}, skip = handle_skip, warning = handle_warning, message = handle_message, } error = handle_error, interrupt = handle_interrupt), error = handle_fatal), }, snapshot_on_cran = function(cnd) { end_test = function() { 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: 26:
> 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", { loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 27: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_and_waic.R: 28: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 29: expect_equal(loo1$estimates, loo2$estimates)tryCatch(withCallingHandlers({ }) eval(code, test_env)
> test_loo_and_waic.R: new_expectations <- the$test_expectations > starting_expectations35: 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")eval(code, test_env)}, skip = handle_skip, warning = handle_warning, message = handle_message,
> test_loo_and_waic.R: error = handle_error, interrupt = handle_interrupt), error = handle_fatal)36:
> test_loo_and_waic.R: eval(code, test_env)30:
> test_loo_and_waic.R: doWithOneRestart(return(expr), restart)37:
> test_loo_and_waic.R: withCallingHandlers({31: eval(code, test_env)withOneRestart(expr, restarts[[1L]]) new_expectations <- the$test_expectations > starting_expectations
> test_loo_and_waic.R: if (snapshot_skipped) {32: skip("On CRAN")withRestarts(tryCatch(withCallingHandlers({ } eval(code, test_env) else if (!new_expectations && skip_on_empty) { new_expectations <- the$test_expectations > starting_expectations skip_empty() if (snapshot_skipped) { } skip("On CRAN")}, expectation = handle_expectation, packageNotFoundError = function(e) { } if (on_cran()) { else if (!new_expectations && skip_on_empty) { skip(paste0("{", e$package, "} is not installed.")) skip_empty() } }}, 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)}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_and_waic.R: if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE38: invokeRestart("muffle_cran_snapshot")doTryCatch(return(expr), name, parentenv, handler)}, skip = handle_skip, warning = handle_warning, message = handle_message,
> test_loo_and_waic.R: error = handle_error, interrupt = handle_interrupt), error = handle_fatal), end_test = function() { })
> test_loo_and_waic.R: 39: 33: tryCatchOne(expr, names, parentenv, handlers[[1L]])test_code(code, parent.frame())
> test_loo_and_waic.R:
> test_loo_and_waic.R: 40: 34: tryCatchList(expr, classes, parentenv, handlers)test_that("loo with cores=1 and cores=2 gives same results", { loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))
> test_loo_and_waic.R: expect_equal(loo1$estimates, loo2$estimates)41: })tryCatch(withCallingHandlers({
> test_loo_and_waic.R: 35: eval(code, test_env)
> test_loo_and_waic.R: 36: eval(code, test_env)eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) {
> test_loo_and_waic.R: skip_empty()37: }withCallingHandlers({}, expectation = handle_expectation, packageNotFoundError = function(e) { eval(code, test_env) if (on_cran()) { new_expectations <- the$test_expectations > starting_expectations skip(paste0("{", e$package, "} is not installed.")) if (snapshot_skipped) { skip("On CRAN") } else if (!new_expectations && skip_on_empty) { skip_empty() }}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot") }}, expectation = handle_expectation, packageNotFoundError = function(e) { if (on_cran()) { skip(paste0("{", e$package, "} is not installed.")) }}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 42: }, 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: doWithOneRestart(return(expr), restart)39:
> test_loo_and_waic.R: tryCatchOne(expr, names, parentenv, handlers[[1L]])43:
> test_loo_and_waic.R: withOneRestart(expr, restarts[[1L]])40:
> test_loo_and_waic.R: tryCatchList(expr, classes, parentenv, handlers)44:
> test_loo_and_waic.R: withRestarts(tryCatch(withCallingHandlers({41: eval(code, test_env)tryCatch(withCallingHandlers({ new_expectations <- the$test_expectations > starting_expectations eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { 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) {}, expectation = handle_expectation, packageNotFoundError = function(e) { skip_empty() if (on_cran()) { }}, 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}, 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")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal), end_test = function() { }) error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_and_waic.R: 42: doWithOneRestart(return(expr), restart)
> test_loo_and_waic.R:
> test_loo_and_waic.R: 45: 43: test_code(code = exprs, env = env, reporter = get_reporter() %||% withOneRestart(expr, restarts[[1L]]) 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({ eval(code, test_env) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) {
> test_loo_and_waic.R: skip("On CRAN")48: }doTryCatch(return(expr), name, parentenv, handler) else if (!new_expectations && skip_on_empty) {
> test_loo_and_waic.R: skip_empty()49: }tryCatchOne(expr, names, parentenv, handlers[[1L]])}, expectation = handle_expectation, packageNotFoundError = function(e) {
> test_loo_and_waic.R: if (on_cran()) {50: skip(paste0("{", e$package, "} is not installed."))tryCatchList(expr, classes, parentenv, handlers) }
> test_loo_and_waic.R: }, snapshot_on_cran = function(cnd) {51: snapshot_skipped <<- TRUEtryCatch(code, testthat_abort_reporter = function(cnd) { invokeRestart("muffle_cran_snapshot") cat(conditionMessage(cnd), "\n")}, skip = handle_skip, warning = handle_warning, message = handle_message, NULL error = handle_error, interrupt = handle_interrupt), error = handle_fatal), })
> test_loo_and_waic.R: 52: with_reporter(multi, test_one_file(path, env = the$testing_env, end_test = function() { })
> test_loo_and_waic.R: 45: test_code(code = exprs, env = env, reporter = get_reporter() %||% shuffle = shuffle)) StopReporter$new())
> test_loo_and_waic.R:
> test_loo_and_waic.R: 53: 46: asNamespace("testthat")$queue_task(path, shuffle)source_file(path, env = env(env), desc = desc, shuffle = shuffle,
> test_loo_and_waic.R: error_call = error_call)54:
> test_loo_and_waic.R: 47: test_one_file(path, env = the$testing_env, shuffle = shuffle)
> test_loo_and_waic.R: (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()) {48: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: 49: tryCatchOne(expr, names, parentenv, handlers[[1L]]) if (!is.list(args)) stop("second argument must be a list") if (quote)
> test_loo_and_waic.R: 50:
> test_loo_and_waic.R: args <- lapply(args, enquote)tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 51: tryCatch(code, testthat_abort_reporter = function(cnd) { .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) { asNamespace("testthat")$queue_task(path, shuffle) cat(conditionMessage(cnd), "\n") NULL})
> test_loo_and_waic.R: 52: }), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), quote = base::quote(TRUE))
> test_loo_and_waic.R: 56: with_reporter(multi, test_one_file(path, env = the$testing_env, base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_and_waic.R: shuffle = shuffle))
> test_loo_and_waic.R: 53: asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_and_waic.R: 57: 54: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), (function (path, shuffle) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, { quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", asNamespace("testthat")$queue_task(path, shuffle) compress = FALSE)})(base::quote("test_loo_and_waic.R"), base::quote(FALSE))
> test_loo_and_waic.R:
> test_loo_and_waic.R: 58: 55: base::withCallingHandlers({(function (what, args, quote = FALSE, envir = parent.frame()) {{ NULL if (!is.list(args)) NULL stop("second argument must be a list") } if (quote) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), args <- lapply(args, enquote) base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, .Internal(do.call(what, args, envir)) quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", })(base::quote(function (path, shuffle) compress = FALSE){ base::flush(base::stdout()) asNamespace("testthat")$queue_task(path, shuffle) base::flush(base::stderr())}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>), { quote = base::quote(TRUE)) NULL
> test_loo_and_waic.R: NULL56: }base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), 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/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", 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/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".error")) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { e <- err$process_call(e) base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) e2 <- err$new_error("error in callr subprocess") cut <- base::which(e2$trace$scope == "global")[1] class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } if (!base::is.na(cut)) { base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", e2$trace <- e2$trace[-(1:cut), ] ".error")) } } if (callr_data$has_otel) {}, interrupt = 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".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)) { err <- callr_data$err e$code <- "301" if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") } class <- base::class msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) if (callr_data$has_otel) { 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".error")) callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } }}, callr_message = function(e) { pxlib$write_fd(3L, data) base::try({ if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) {
> test_loo_and_waic.R: callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } base::invokeRestart("cli_message_handled") 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"))) { } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } base::invokeRestart("muffleMessage") } })})
> test_loo_and_waic.R: 59: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_and_waic.R: })})
> test_loo_and_waic.R: 59: doTryCatch(return(expr), name, parentenv, handler)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:
> 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: 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: 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: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_and_waic.R: 65: base::tryCatch(base::withCallingHandlers({ { NULL65: base::tryCatch(base::withCallingHandlers({ { NULL NULL } NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", compress = FALSE) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe7b14ee8f"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", compress = FALSE) base::flush(base::stdout()) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::flush(base::stderr()) { NULL NULL } base::invisible() base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) {}, 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) 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) } 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) 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] 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)) { 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".error")) 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) ".error")) }}, interrupt = function(e) { { 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") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) 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) 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".error")) }}, callr_message = function(e) { base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" 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), ] } 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") } }) } 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/Rtmprw9kn7/callr-rs-result-16bfe1b3a2d6a", ".error"))}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) }
> test_loo_and_waic.R: if (FALSE) { base::q(save = "no", status = 1) }}, 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)) { } base::invisible()}, interrupt = function(e) { { NULL NULL e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}) 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)
> test_loo_and_waic.R: if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) {An irrecoverable exception occurred. R is aborting now ...
> test_loo_and_waic.R: base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { { NULL NULL } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()})
> test_loo_and_waic.R: An irrecoverable exception occurred. R is aborting now ...
Saving _problems/test_loo_and_waic-30.R
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: *** caught segfault ***
> test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: *** caught segfault ***
> test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: Traceback:
> test_loo_predictive_metric.R: 1: outer(X, Y)
> test_loo_predictive_metric.R: 2: -theta %o% x
> test_loo_predictive_metric.R: 3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
> test_loo_predictive_metric.R: 4: psis_smooth_tail(lw_tail, cutoff)
> test_loo_predictive_metric.R: 5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
> test_loo_predictive_metric.R: 6: FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 7: lapply(X = S, FUN = FUN, ...)
> test_loo_predictive_metric.R: 8: doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 10: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 11: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ")
> test_loo_predictive_metric.R: Traceback:
> test_loo_predictive_metric.R: 1: outer(X, Y) 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 : "
> test_loo_predictive_metric.R: 2: -theta %o% x
> test_loo_predictive_metric.R: msg <- paste0(prefix, conditionMessage(e), "\n") 3: .Internal(seterrmessage(msg[1L]))posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE) 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: }) 4:
> test_loo_predictive_metric.R: psis_smooth_tail(lw_tail, cutoff)12:
> test_loo_predictive_metric.R: try(lapply(X = S, FUN = FUN, ...), silent = TRUE) 5:
> test_loo_predictive_metric.R: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])13:
> test_loo_predictive_metric.R: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) 6:
> test_loo_predictive_metric.R: FUN(X[[i]], ...)14:
> test_loo_predictive_metric.R: FUN(X[[i]], ...) 7:
> test_loo_predictive_metric.R: lapply(X = S, FUN = FUN, ...)15:
> test_loo_predictive_metric.R: lapply(seq_len(cores), inner.do) 8:
> test_loo_predictive_metric.R: doTryCatch(return(expr), name, parentenv, handler)16:
> test_loo_predictive_metric.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_predictive_metric.R: 17: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, method = method)
> test_loo_predictive_metric.R: 18: importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores, method = "psis")
> test_loo_predictive_metric.R: 19: psis.matrix(-LL, r_eff = r_eff, cores = 2)
> test_loo_predictive_metric.R: 20: psis(-LL, r_eff = r_eff, cores = 2)
> test_loo_predictive_metric.R: 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 21: 10: eval(code, test_env)tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 22: 11: eval(code, test_env)tryCatch(expr, error = function(e) {
> test_loo_predictive_metric.R: call <- conditionCall(e)23: if (!is.null(call)) {withCallingHandlers({ if (identical(call[[1L]], quote(doTryCatch))) eval(code, test_env) call <- sys.call(-4L) new_expectations <- the$test_expectations > starting_expectations dcall <- deparse(call, nlines = 1L) if (snapshot_skipped) { prefix <- paste("Error in", dcall, ": ") skip("On CRAN") LONG <- 75L } sm <- strsplit(conditionMessage(e), "\n")[[1L]] else if (!new_expectations && skip_on_empty) { w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") skip_empty() if (is.na(w)) } w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], }, expectation = handle_expectation, packageNotFoundError = function(e) { type = "b") if (on_cran()) { if (w > LONG) skip(paste0("{", e$package, "} is not installed.")) prefix <- paste0(prefix, "\n ") } }}, snapshot_on_cran = function(cnd) { else prefix <- "Error : " snapshot_skipped <<- TRUE msg <- paste0(prefix, conditionMessage(e), "\n") invokeRestart("muffle_cran_snapshot") .Internal(seterrmessage(msg[1L]))}, skip = handle_skip, warning = handle_warning, message = handle_message, if (!silent && isTRUE(getOption("show.error.messages"))) { error = handle_error, interrupt = handle_interrupt) cat(msg, file = outFile)
> test_loo_predictive_metric.R: .Internal(printDeferredWarnings())24: }doTryCatch(return(expr), name, parentenv, handler) invisible(structure(msg, class = "try-error", condition = e))
> test_loo_predictive_metric.R: })25:
> test_loo_predictive_metric.R: tryCatchOne(expr, names, parentenv, handlers[[1L]])12:
> test_loo_predictive_metric.R: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)26:
> test_loo_predictive_metric.R: 13: tryCatchList(expr, classes, parentenv, handlers)
> test_loo_predictive_metric.R: 27: tryCatch(withCallingHandlers({ eval(code, test_env)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) new_expectations <- the$test_expectations > starting_expectations
> test_loo_predictive_metric.R: 14: FUN(X[[i]], ...)
> test_loo_predictive_metric.R: 15: if (snapshot_skipped) {lapply(seq_len(cores), inner.do) skip("On CRAN")
> test_loo_predictive_metric.R: } 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.")) }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]))}, snapshot_on_cran = function(cnd) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 17: 28: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores, doWithOneRestart(return(expr), restart) method = method)
> test_loo_predictive_metric.R:
> test_loo_predictive_metric.R: 29: 18: withOneRestart(expr, restarts[[1L]])importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores,
> test_loo_predictive_metric.R: method = "psis")30:
> test_loo_predictive_metric.R: withRestarts(tryCatch(withCallingHandlers({19: eval(code, test_env)psis.matrix(-LL, r_eff = r_eff, cores = 2) new_expectations <- the$test_expectations > starting_expectations
> test_loo_predictive_metric.R: if (snapshot_skipped) {20: skip("On CRAN")psis(-LL, r_eff = r_eff, cores = 2) }
> test_loo_predictive_metric.R: else if (!new_expectations && skip_on_empty) {21: skip_empty()eval(code, test_env) }
> test_loo_predictive_metric.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {22: if (on_cran()) {eval(code, test_env) skip(paste0("{", e$package, "} is not installed."))
> test_loo_predictive_metric.R: }23: }, snapshot_on_cran = function(cnd) {withCallingHandlers({ snapshot_skipped <<- TRUE eval(code, test_env) invokeRestart("muffle_cran_snapshot") new_expectations <- the$test_expectations > starting_expectations}, skip = handle_skip, warning = handle_warning, message = handle_message, if (snapshot_skipped) { error = handle_error, interrupt = handle_interrupt), error = handle_fatal), skip("On CRAN") end_test = function() { } }) else if (!new_expectations && skip_on_empty) {
> test_loo_predictive_metric.R: skip_empty()31: }test_code(code = exprs, env = env, reporter = get_reporter() %||% }, expectation = handle_expectation, packageNotFoundError = function(e) { StopReporter$new()) if (on_cran()) {
> test_loo_predictive_metric.R: skip(paste0("{", e$package, "} is not installed."))32: }source_file(path, env = env(env), desc = desc, shuffle = shuffle, }, snapshot_on_cran = function(cnd) { error_call = error_call) snapshot_skipped <<- TRUE
> test_loo_predictive_metric.R: invokeRestart("muffle_cran_snapshot")33: }, skip = handle_skip, warning = handle_warning, message = handle_message, test_one_file(path, env = the$testing_env, shuffle = shuffle) error = handle_error, interrupt = handle_interrupt)
> test_loo_predictive_metric.R: 24: doTryCatch(return(expr), name, parentenv, handler)
> 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) new_expectations <- the$test_expectations > starting_expectations if (snapshot_skipped) { skip("On CRAN")
> test_loo_predictive_metric.R: 37: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})
> test_loo_predictive_metric.R: 38: with_reporter(multi, test_one_file(path, env = the$testing_env, } shuffle = shuffle)) 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) {
> test_loo_predictive_metric.R: 39: asNamespace("testthat")$queue_task(path, shuffle)
> test_loo_predictive_metric.R: 40: (function (path, shuffle) { snapshot_skipped <<- TRUE invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message, error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
> test_loo_predictive_metric.R: 28: doWithOneRestart(return(expr), restart)
> test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]])
> test_loo_predictive_metric.R: asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE))
> test_loo_predictive_metric.R: 41: (function (what, args, quote = FALSE, envir = parent.frame()) { if (!is.list(args)) stop("second argument must be a list") if (quote) 30: args <- lapply(args, enquote)withRestarts(tryCatch(withCallingHandlers({ .Internal(do.call(what, args, envir)) eval(code, test_env)})(base::quote(function (path, shuffle) new_expectations <- the$test_expectations > starting_expectations{ if (snapshot_skipped) { asNamespace("testthat")$queue_task(path, shuffle) skip("On CRAN")}), base::quote(list("test_loo_predictive_metric.R", FALSE)), } envir = base::quote(<environment>), quote = base::quote(TRUE)) else if (!new_expectations && skip_on_empty) {
> test_loo_predictive_metric.R: skip_empty()42: }base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_predictive_metric.R: 43: }, expectation = handle_expectation, packageNotFoundError = function(e) {base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", compress = FALSE)
> test_loo_predictive_metric.R: 44: base::withCallingHandlers({ { if (on_cran()) { NULL skip(paste0("{", e$package, "} is not installed.")) NULL } }}, snapshot_on_cran = function(cnd) { base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), snapshot_skipped <<- TRUE base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, invokeRestart("muffle_cran_snapshot") quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", }, skip = handle_skip, warning = handle_warning, message = handle_message, compress = FALSE) error = handle_error, interrupt = handle_interrupt), error = handle_fatal), base::flush(base::stdout()) end_test = function() { base::flush(base::stderr()) }) {
> test_loo_predictive_metric.R: NULL31: NULLtest_code(code = exprs, env = env, reporter = get_reporter() %||% } StopReporter$new()) base::invisible()
> test_loo_predictive_metric.R: }, error = function(e) {32: {source_file(path, env = env(env), desc = desc, shuffle = shuffle, callr_data <- base::as.environment("tools:callr")$`__callr_data__` error_call = error_call) err <- callr_data$err
> test_loo_predictive_metric.R: if (FALSE) {33: base::assign(".Traceback", base::.traceback(4), envir = callr_data)test_one_file(path, env = the$testing_env, shuffle = shuffle) utils::dump.frames("__callr_dump__")
> test_loo_predictive_metric.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, 34: envir = callr_data)doTryCatch(return(expr), name, parentenv, handler) base::rm("__callr_dump__", envir = .GlobalEnv)
> test_loo_predictive_metric.R: }35: e <- err$process_call(e)tryCatchOne(expr, names, parentenv, handlers[[1L]]) 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]
> test_loo_predictive_metric.R: if (!base::is.na(cut)) {36: e2$trace <- e2$trace[-(1:cut), ]tryCatchList(expr, classes, parentenv, handlers) }
> test_loo_predictive_metric.R: if (callr_data$has_otel) {37: callr_data$otel_span$record_exception(e2)tryCatch(code, testthat_abort_reporter = function(cnd) { } cat(conditionMessage(cnd), "\n") base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", NULL ".error"))}) }
> test_loo_predictive_metric.R: }, interrupt = function(e) {38: {with_reporter(multi, test_one_file(path, env = the$testing_env, callr_data <- base::as.environment("tools:callr")$`__callr_data__` shuffle = shuffle)) err <- callr_data$err
> test_loo_predictive_metric.R: if (FALSE) {39: base::assign(".Traceback", base::.traceback(4), envir = callr_data)asNamespace("testthat")$queue_task(path, shuffle) utils::dump.frames("__callr_dump__")
> test_loo_predictive_metric.R: base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, 40: envir = callr_data)(function (path, shuffle) base::rm("__callr_dump__", envir = .GlobalEnv){ } asNamespace("testthat")$queue_task(path, shuffle) e <- err$process_call(e)})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE)) e2 <- err$new_error("error in callr subprocess")
> test_loo_predictive_metric.R: class <- base::class41: class(e2) <- base::c("callr_remote_error", class(e2))(function (what, args, quote = FALSE, envir = parent.frame()) e2 <- err$add_trace_back(e2){ cut <- base::which(e2$trace$scope == "global")[1] if (!is.list(args)) if (!base::is.na(cut)) { stop("second argument must be a list") e2$trace <- e2$trace[-(1:cut), ] if (quote) } args <- lapply(args, enquote) if (callr_data$has_otel) { .Internal(do.call(what, args, envir)) callr_data$otel_span$record_exception(e2)})(base::quote(function (path, shuffle) }{ base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) }}, callr_message = function(e) { base::try({ asNamespace("testthat")$queue_task(path, shuffle) callr_data <- base::as.environment("tools:callr")$`__callr_data__`}), base::quote(list("test_loo_predictive_metric.R", FALSE)), pxlib <- callr_data$pxlib envir = base::quote(<environment>), quote = base::quote(TRUE)) if (base::is.null(e$code)) {
> test_loo_predictive_metric.R: e$code <- "301"42: }base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE)
> test_loo_predictive_metric.R: 43: msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", compress = FALSE)
> test_loo_predictive_metric.R: 44: base::withCallingHandlers({ { NULL NULL } base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", NULL))) compress = FALSE) 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)) } base::flush(base::stdout()) pxlib$write_fd(3L, data) base::flush(base::stderr()) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { { base::invokeRestart("cli_message_handled") NULL } NULL else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { } base::invokeRestart("muffleMessage") base::invisible() }}, error = function(e) { }) {}) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_predictive_metric.R: err <- callr_data$err45: if (FALSE) {doTryCatch(return(expr), name, parentenv, handler)
> test_loo_predictive_metric.R: 46:
> test_loo_predictive_metric.R: base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, tryCatchOne(expr, names, parentenv, handlers[[1L]])
> test_loo_predictive_metric.R: 47: tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) 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::class48: class(e2) <- base::c("callr_remote_error", class(e2))doTryCatch(return(expr), name, parentenv, handler) e2 <- err$add_trace_back(e2)
> test_loo_predictive_metric.R: cut <- base::which(e2$trace$scope == "global")[1]49: if (!base::is.na(cut)) {tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), e2$trace <- e2$trace[-(1:cut), ] names[nh], parentenv, handlers[[nh]]) }
> test_loo_predictive_metric.R: if (callr_data$has_otel) {50: callr_data$otel_span$record_exception(e2)tryCatchList(expr, classes, parentenv, handlers) }
> test_loo_predictive_metric.R: base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", 51: ".error"))base::tryCatch(base::withCallingHandlers({ } {}, interrupt = function(e) { NULL { NULL callr_data <- base::as.environment("tools:callr")$`__callr_data__` } err <- callr_data$err base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { NULL NULL } base::invisible()}, error = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` if (FALSE) { err <- callr_data$err base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) 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") class(e2) <- base::c("callr_remote_error", class(e2)) class <- base::class e2 <- err$add_trace_back(e2) class(e2) <- base::c("callr_remote_error", class(e2)) cut <- base::which(e2$trace$scope == "global")[1] e2 <- err$add_trace_back(e2) if (!base::is.na(cut)) { cut <- base::which(e2$trace$scope == "global")[1] 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/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib 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/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { if (base::is.null(e$code)) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) 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)) utils::dump.frames("__callr_dump__") } base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, pxlib$write_fd(3L, data) envir = callr_data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::rm("__callr_dump__", envir = .GlobalEnv) base::invokeRestart("cli_message_handled") } } 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) { else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) } }}, callr_message = function(e) { }) base::try({}) callr_data <- base::as.environment("tools:callr")$`__callr_data__`
> test_loo_predictive_metric.R: pxlib <- callr_data$pxlib45: if (base::is.null(e$code)) {doTryCatch(return(expr), name, parentenv, handler) e$code <- "301"
> test_loo_predictive_metric.R: }46: msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, tryCatchOne(expr, names, parentenv, handlers[[1L]]) NULL)))
> test_loo_predictive_metric.R: data <- base::paste0(e$code, " ", base::nchar(msg), "\n", 47: msg)tryCatchList(expr, names[-nh], parentenv, handlers[-nh]) if (callr_data$has_otel) {
> test_loo_predictive_metric.R: callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code))48: }doTryCatch(return(expr), name, parentenv, handler) pxlib$write_fd(3L, data)
> test_loo_predictive_metric.R: if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) {49: base::invokeRestart("cli_message_handled")tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), } names[nh], parentenv, handlers[[nh]]) else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {
> test_loo_predictive_metric.R: base::invokeRestart("muffleMessage")50: }tryCatchList(expr, classes, parentenv, handlers) })
> test_loo_predictive_metric.R: }), error = function(e) {51: {base::tryCatch(base::withCallingHandlers({ NULL { NULL NULL } NULL if (FALSE) { } base::try(base::stop(e)) base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/Rtmprw9kn7/callr-fun-16bfe51cd5142"), base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, quote = TRUE), file = "/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", compress = FALSE) base::flush(base::stdout()) base::flush(base::stderr()) { } NULL if (FALSE) { NULL base::q(save = "no", status = 1) } } base::invisible() base::invisible()}, error = function(e) {}, interrupt = function(e) { { { 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)
> test_loo_predictive_metric.R: if (FALSE) { base::q(save = "no", status = 1) } base::invisible()})
> test_loo_predictive_metric.R: utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data)An irrecoverable exception occurred. R is aborting now ...
> test_loo_predictive_metric.R: base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) }}, interrupt = function(e) { { callr_data <- base::as.environment("tools:callr")$`__callr_data__` err <- callr_data$err if (FALSE) { base::assign(".Traceback", base::.traceback(4), envir = callr_data) utils::dump.frames("__callr_dump__") base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, envir = callr_data) base::rm("__callr_dump__", envir = .GlobalEnv) } e <- err$process_call(e) e2 <- err$new_error("error in callr subprocess") class <- base::class class(e2) <- base::c("callr_remote_error", class(e2)) e2 <- err$add_trace_back(e2) cut <- base::which(e2$trace$scope == "global")[1] if (!base::is.na(cut)) { e2$trace <- e2$trace[-(1:cut), ] } if (callr_data$has_otel) { callr_data$otel_span$record_exception(e2) } base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/Rtmprw9kn7/callr-rs-result-16bfe7e91ee02", ".error")) }}, callr_message = function(e) { base::try({ callr_data <- base::as.environment("tools:callr")$`__callr_data__` pxlib <- callr_data$pxlib if (base::is.null(e$code)) { e$code <- "301" } msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, NULL))) data <- base::paste0(e$code, " ", base::nchar(msg), "\n", msg) if (callr_data$has_otel) { callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code)) } pxlib$write_fd(3L, data) if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) { base::invokeRestart("cli_message_handled") } else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) { base::invokeRestart("muffleMessage") } })}), error = function(e) { { NULL NULL } if (FALSE) { base::try(base::stop(e)) } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()}, interrupt = function(e) { { NULL NULL } if (FALSE) { base::q(save = "no", status = 1) } base::invisible()})
> test_loo_predictive_metric.R: An irrecoverable exception occurred. R is aborting now ...
Saving _problems/test_loo_predictive_metric-4.R
[ FAIL 2 | WARN 1 | SKIP 34 | PASS 847 ]
══ Skipped tests (34) ══════════════════════════════════════════════════════════
• On CRAN (32): 'test_loo_subsampling_cases.R:4:3',
'test_loo_subsampling_cases.R:256:3', 'test_E_loo.R:134:1',
'test_E_loo.R:142:1', 'test_compare.R:91:1', 'test_compare.R:122:1',
'test_compare.R:160:1', 'test_crps.R:27:1',
'test_deprecated_extractors.R:8:1', 'test_deprecated_extractors.R:106:1',
'test_gpdfit.R:1:1', 'test_kfold_helpers.R:139:1',
'test_loo_and_waic.R:23:1', 'test_loo_moment_matching.R:157:1',
'test_loo_moment_matching.R:247:1', 'test_loo_moment_matching.R:365:1',
'test_model_weighting.R:69:1', 'test_print_plot.R:41:1',
'test_print_plot.R:45:1', 'test_print_plot.R:151:1',
'test_print_plot.R:169:1', 'test_print_plot.R:175:1',
'test_print_plot.R:181:1', 'test_psis.R:13:1', 'test_psis.R:39:1',
'test_psislw.R:15:1', 'test_relative_eff.R:7:1', 'test_relative_eff.R:43:3',
'test_loo_subsampling.R:896:3', 'test_loo_subsampling.R:1077:3',
'test_tisis.R:76:1', 'test_tisis.R:213:1'
• Sys.info()[["sysname"]] == "Darwin" && R.version$arch == "aarch64" is TRUE
(2): 'test_loo_moment_matching.R:468:3', 'test_psis.R:157:3'
══ Failed tests ════════════════════════════════════════════════════════════════
── Error ('test_loo_and_waic.R:30:3'): loo with cores=1 and cores=2 gives same results ──
Error in `vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)`: values must be length 1000,
but FUN(X[[1]]) result is length 0
Backtrace:
▆
1. ├─base::suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2)) at test_loo_and_waic.R:30:3
2. │ └─base::withCallingHandlers(...)
3. ├─loo::loo(LLarr, r_eff = r_eff_arr, cores = 2)
4. └─loo::loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
5. └─loo:::importance_sampling.array(...)
6. └─loo:::do_importance_sampling(...)
7. └─loo:::psis_apply(lw_list, "log_weights", fun_val = numeric(S))
8. └─base::vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)
── Error ('test_loo_predictive_metric.R:4:1'): (code run outside of `test_that()`) ──
Error in `vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)`: values must be length 1000,
but FUN(X[[1]]) result is length 0
Backtrace:
▆
1. ├─loo::psis(-LL, r_eff = r_eff, cores = 2) at test_loo_predictive_metric.R:4:1
2. └─loo:::psis.matrix(-LL, r_eff = r_eff, cores = 2)
3. └─loo:::importance_sampling.matrix(...)
4. └─loo:::do_importance_sampling(...)
5. └─loo:::psis_apply(lw_list, "log_weights", fun_val = numeric(S))
6. └─base::vapply(x, FUN = match.arg(fun), FUN.VALUE = fun_val, item)
[ FAIL 2 | WARN 1 | SKIP 34 | PASS 847 ]
Error:
! Test failures.
Execution halted
Flavor: r-oldrel-macos-arm64