Running ‘testthat.R’ [13s/7s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(loo)
  This is loo version 2.10.0
  - Online documentation and vignettes at mc-stan.org/loo
  - As of v2.0.0 loo defaults to 1 core but we recommend using as many as possible. Use the 'cores' argument or set options(mc.cores = NUM_CORES) for an entire session. 
  > library(testthat)
  
  Attaching package: 'testthat'
  
  The following object is masked from 'package:loo':
  
      compare
  
  > Sys.setenv("R_TESTS" = "")
  > test_check("loo")
  Starting 2 test processes.
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  *** caught segfault ***
  > test_loo_and_waic.R: address 0x110, cause 'invalid permissions'
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  *** caught segfault ***
  > test_loo_and_waic.R: address 0x110, cause 'invalid permissions'
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: Traceback:
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: Traceback:
  > test_loo_and_waic.R:  1:  1: outer(X, Y)outer(X, Y)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  2:  2: -theta %o% x-theta %o% x
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  3:  3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  4:  4: psis_smooth_tail(lw_tail, cutoff)psis_smooth_tail(lw_tail, cutoff)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  5:  5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  6:  6: FUN(X[[i]], ...)FUN(X[[i]], ...)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  7:  7: lapply(X = S, FUN = FUN, ...)lapply(X = S, FUN = FUN, ...)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  8:  8: doTryCatch(return(expr), name, parentenv, handler)doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R:  9:  9: tryCatchOne(expr, names, parentenv, handlers[[1L]])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, ": ")
  > test_loo_and_waic.R: 10: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_and_waic.R: 11: tryCatch(expr, error = function(e) {        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)     call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)            prefix <- paste0(prefix, "\n  ")        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")    else prefix <- "Error : "        if (is.na(w))     msg <- paste0(prefix, conditionMessage(e), "\n")            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())                type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    }    else prefix <- "Error : "    invisible(structure(msg, class = "try-error", condition = e))    msg <- paste0(prefix, conditionMessage(e), "\n")})    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())
  > test_loo_and_waic.R:     }12:     invisible(structure(msg, class = "try-error", condition = e))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: 
  > test_loo_and_waic.R: FUN(X[[i]], ...)12: 
  > test_loo_and_waic.R: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)15: 
  > test_loo_and_waic.R: lapply(seq_len(cores), inner.do)13: 
  > 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, sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    method = is_method)
  > test_loo_and_waic.R: 14: FUN(X[[i]], ...)
  > test_loo_and_waic.R: 15: 
  > test_loo_and_waic.R: 19: loo.array(LLarr, r_eff = r_eff_arr, cores = 2)
  > test_loo_and_waic.R: 20: 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[, loo(LLarr, r_eff = r_eff_arr, cores = 2)    i], tail_len_i = tail_len[i]))
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 21: 17: withCallingHandlers(expr, warning = function(w) if (inherits(w, do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores,     classes)) tryInvokeRestart("muffleWarning"))    method = method)
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 22: 18: suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))importance_sampling.array(log_ratios = -x, r_eff = r_eff, cores = cores, 
  > test_loo_and_waic.R:     method = is_method)23: 
  > test_loo_and_waic.R: eval(code, test_env)19: 
  > test_loo_and_waic.R: loo.array(LLarr, r_eff = r_eff_arr, cores = 2)24: 
  > test_loo_and_waic.R: eval(code, test_env)20: 
  > test_loo_and_waic.R: loo(LLarr, r_eff = r_eff_arr, cores = 2)25: 
  > test_loo_and_waic.R: withCallingHandlers({21:     eval(code, test_env)withCallingHandlers(expr, warning = function(w) if (inherits(w,     new_expectations <- the$test_expectations > starting_expectations    classes)) tryInvokeRestart("muffleWarning"))    if (snapshot_skipped) {
  > test_loo_and_waic.R:         skip("On CRAN")22:     }suppressWarnings(loo(LLarr, r_eff = r_eff_arr, cores = 2))    else if (!new_expectations && skip_on_empty) {
  > test_loo_and_waic.R:         skip_empty()23:     }eval(code, test_env)}, expectation = handle_expectation, packageNotFoundError = function(e) {
  > test_loo_and_waic.R:     if (on_cran()) {24:         skip(paste0("{", e$package, "} is not installed."))eval(code, test_env)    }
  > test_loo_and_waic.R: }, snapshot_on_cran = function(cnd) {25:     snapshot_skipped <<- TRUEwithCallingHandlers({    invokeRestart("muffle_cran_snapshot")    eval(code, test_env)}, skip = handle_skip, warning = handle_warning, message = handle_message,     new_expectations <- the$test_expectations > starting_expectations    error = handle_error, interrupt = handle_interrupt)
  > test_loo_and_waic.R: 26: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_and_waic.R:     if (snapshot_skipped) {        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()27:     }tryCatchOne(expr, names, parentenv, handlers[[1L]])}, 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) {28:     snapshot_skipped <<- TRUEtryCatchList(expr, classes, parentenv, handlers)    invokeRestart("muffle_cran_snapshot")
  > test_loo_and_waic.R: }, skip = handle_skip, warning = handle_warning, message = handle_message,     error = handle_error, interrupt = handle_interrupt)
  > test_loo_and_waic.R: 26: doTryCatch(return(expr), name, parentenv, handler)29: 
  > test_loo_and_waic.R: tryCatch(withCallingHandlers({27:     eval(code, test_env)tryCatchOne(expr, names, parentenv, handlers[[1L]])    new_expectations <- the$test_expectations > starting_expectations
  > test_loo_and_waic.R:     if (snapshot_skipped) {28:         skip("On CRAN")
  > test_loo_and_waic.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."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUEtryCatchList(expr, classes, parentenv, handlers)    invokeRestart("muffle_cran_snapshot")
  > test_loo_and_waic.R: 29: tryCatch(withCallingHandlers({    eval(code, test_env)    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")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()
  > test_loo_and_waic.R: 30: doWithOneRestart(return(expr), restart)
  > test_loo_and_waic.R: 31:     }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))    }withOneRestart(expr, restarts[[1L]])}, snapshot_on_cran = function(cnd) {
  > test_loo_and_waic.R:     snapshot_skipped <<- TRUE32:     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: withRestarts(tryCatch(withCallingHandlers({doWithOneRestart(return(expr), restart)    eval(code, test_env)
  > test_loo_and_waic.R:     new_expectations <- the$test_expectations > starting_expectations31:     if (snapshot_skipped) {withOneRestart(expr, restarts[[1L]])        skip("On CRAN")
  > test_loo_and_waic.R:     }32:     else if (!new_expectations && skip_on_empty) {withRestarts(tryCatch(withCallingHandlers({        skip_empty()    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()    if (on_cran()) {    }        skip(paste0("{", e$package, "} is not installed."))}, expectation = handle_expectation, packageNotFoundError = function(e) {    }    if (on_cran()) {}, snapshot_on_cran = function(cnd) {        skip(paste0("{", e$package, "} is not installed."))    snapshot_skipped <<- TRUE    }    invokeRestart("muffle_cran_snapshot")}, snapshot_on_cran = function(cnd) {}, skip = handle_skip, warning = handle_warning, message = handle_message,     snapshot_skipped <<- TRUE    error = handle_error, interrupt = handle_interrupt), error = handle_fatal),     invokeRestart("muffle_cran_snapshot")    end_test = function() {}, skip = handle_skip, warning = handle_warning, message = handle_message,     })    error = handle_error, interrupt = handle_interrupt), error = handle_fatal), 
  > test_loo_and_waic.R:     end_test = function() {33:     })test_code(code, parent.frame())
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 33: 34: test_code(code, parent.frame())test_that("loo with cores=1 and cores=2 gives same results",     {        loo2 <- suppressWarnings(loo(LLarr, r_eff = r_eff_arr,             cores = 2))        expect_equal(loo1$estimates, loo2$estimates)
  > 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,     })
  > test_loo_and_waic.R: 35: eval(code, test_env)
  > test_loo_and_waic.R:             cores = 2))        expect_equal(loo1$estimates, loo2$estimates)    })
  > test_loo_and_waic.R: 35: 36: eval(code, test_env)eval(code, test_env)
  > test_loo_and_waic.R: 37: withCallingHandlers({    eval(code, test_env)
  > test_loo_and_waic.R: 36: eval(code, test_env)
  > test_loo_and_waic.R: 37:     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)withCallingHandlers({
  > test_loo_and_waic.R:     eval(code, test_env)38:     new_expectations <- the$test_expectations > starting_expectationsdoTryCatch(return(expr), name, parentenv, handler)    if (snapshot_skipped) {
  > test_loo_and_waic.R:         skip("On CRAN")39:     }tryCatchOne(expr, names, parentenv, handlers[[1L]])    else if (!new_expectations && skip_on_empty) {
  > test_loo_and_waic.R:         skip_empty()40:     }tryCatchList(expr, classes, parentenv, handlers)}, expectation = handle_expectation, packageNotFoundError = function(e) {
  > test_loo_and_waic.R:     if (on_cran()) {41:         skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE    invokeRestart("muffle_cran_snapshot")tryCatch(withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }}, skip = handle_skip, warning = handle_warning, message = handle_message,     else if (!new_expectations && skip_on_empty) {    error = handle_error, interrupt = handle_interrupt)
  > test_loo_and_waic.R: 38: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_and_waic.R: 39: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_and_waic.R: 40:         skip_empty()tryCatchList(expr, classes, parentenv, handlers)    }
  > test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {41:     if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUEtryCatch(withCallingHandlers({    invokeRestart("muffle_cran_snapshot")    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }}, 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)    else if (!new_expectations && skip_on_empty) {
  > test_loo_and_waic.R:         skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))43:     }withOneRestart(expr, restarts[[1L]])
  > test_loo_and_waic.R: 44: withRestarts(tryCatch(withCallingHandlers({    eval(code, test_env)}, 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)    new_expectations <- the$test_expectations > starting_expectations
  > test_loo_and_waic.R:     if (snapshot_skipped) {42:         skip("On CRAN")doWithOneRestart(return(expr), restart)    }
  > test_loo_and_waic.R:     else if (!new_expectations && skip_on_empty) {43:         skip_empty()withOneRestart(expr, restarts[[1L]])    }
  > test_loo_and_waic.R: }, expectation = handle_expectation, packageNotFoundError = function(e) {44:     if (on_cran()) {withRestarts(tryCatch(withCallingHandlers({        skip(paste0("{", e$package, "} is not installed."))    eval(code, test_env)    }    new_expectations <- the$test_expectations > starting_expectations}, snapshot_on_cran = function(cnd) {    if (snapshot_skipped) {    snapshot_skipped <<- TRUE        skip("On CRAN")    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:     else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {45: test_code(code = exprs, env = env, reporter = get_reporter() %||%     StopReporter$new())
  > test_loo_and_waic.R: 46:         skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE    invokeRestart("muffle_cran_snapshot")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)}, skip = handle_skip, warning = handle_warning, message = handle_message, 
  > test_loo_and_waic.R: 48: 
  > test_loo_and_waic.R:     error = handle_error, interrupt = handle_interrupt), error = handle_fatal), doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_and_waic.R:     end_test = function() {    })
  > test_loo_and_waic.R: 45: 49: test_code(code = exprs, env = env, reporter = get_reporter() %||% tryCatchOne(expr, names, parentenv, handlers[[1L]])    StopReporter$new())
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 50: 46: tryCatchList(expr, classes, parentenv, handlers)source_file(path, env = env(env), desc = desc, shuffle = shuffle, 
  > test_loo_and_waic.R:     error_call = error_call)
  > test_loo_and_waic.R: 47: test_one_file(path, env = the$testing_env, shuffle = shuffle)51: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL
  > test_loo_and_waic.R: 48: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_and_waic.R: 49: })tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 52: 50: with_reporter(multi, test_one_file(path, env = the$testing_env,     shuffle = shuffle))
  > test_loo_and_waic.R: 53: asNamespace("testthat")$queue_task(path, shuffle)tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_and_waic.R: 51: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")
  > test_loo_and_waic.R:     NULL54: })(function (path, shuffle) 
  > test_loo_and_waic.R: {52:     asNamespace("testthat")$queue_task(path, shuffle)with_reporter(multi, test_one_file(path, env = the$testing_env, })(base::quote("test_loo_and_waic.R"), base::quote(FALSE))    shuffle = shuffle))
  > test_loo_and_waic.R: 
  > test_loo_and_waic.R: 55: 53: (function (what, args, quote = FALSE, envir = parent.frame()) asNamespace("testthat")$queue_task(path, shuffle){
  > test_loo_and_waic.R:     if (!is.list(args)) 54:         stop("second argument must be a list")(function (path, shuffle)     if (quote) {        args <- lapply(args, enquote)    asNamespace("testthat")$queue_task(path, shuffle)    .Internal(do.call(what, args, envir))})(base::quote("test_loo_and_waic.R"), base::quote(FALSE))})(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: base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     quote = TRUE)
  > test_loo_and_waic.R: 57: 
  > test_loo_and_waic.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"), 55:     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv, (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/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         args <- lapply(args, enquote)    compress = FALSE)    .Internal(do.call(what, args, envir))
  > test_loo_and_waic.R: })(base::quote(function (path, shuffle) 58: {base::withCallingHandlers({    asNamespace("testthat")$queue_task(path, shuffle)    {}), base::quote(list("test_loo_and_waic.R", FALSE)), envir = base::quote(<environment>),         NULL    quote = base::quote(TRUE))        NULL
  > test_loo_and_waic.R:     }56:     base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"), base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",     quote = TRUE)        compress = FALSE)
  > test_loo_and_waic.R:     base::flush(base::stdout())57:     base::flush(base::stderr())base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),     {    base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         NULL    quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         NULL    compress = FALSE)    }
  > test_loo_and_waic.R:     base::invisible()58: }, error = function(e) {base::withCallingHandlers({    {    {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        NULL        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__`,         NULL                envir = callr_data)    }            base::rm("__callr_dump__", envir = .GlobalEnv)    base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),         }        base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         e <- err$process_call(e)        quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         compress = FALSE)    base::flush(base::stdout())    base::flush(base::stderr())    {        e2 <- err$new_error("error in callr subprocess")        NULL        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)) {        NULL            e2$trace <- e2$trace[-(1:cut), ]    }        }    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/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         err <- callr_data$err            ".error"))        if (FALSE) {    }            base::assign(".Traceback", base::.traceback(4), envir = callr_data)}, interrupt = function(e) {            utils::dump.frames("__callr_dump__")    {            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,         callr_data <- base::as.environment("tools:callr")$`__callr_data__`                envir = callr_data)        err <- callr_data$err            base::rm("__callr_dump__", envir = .GlobalEnv)        if (FALSE) {        }            base::assign(".Traceback", base::.traceback(4), envir = callr_data)        e <- err$process_call(e)            utils::dump.frames("__callr_dump__")        e2 <- err$new_error("error in callr subprocess")            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,         class <- base::class                envir = callr_data)        class(e2) <- base::c("callr_remote_error", class(e2))            base::rm("__callr_dump__", envir = .GlobalEnv)        e2 <- err$add_trace_back(e2)        }        cut <- base::which(e2$trace$scope == "global")[1]        e <- err$process_call(e)        if (!base::is.na(cut)) {        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) {            e2$trace <- e2$trace[-(1:cut), ]            callr_data$otel_span$record_exception(e2)        }        }        if (callr_data$has_otel) {        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",             callr_data$otel_span$record_exception(e2)            ".error"))        }    }        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268", }, callr_message = function(e) {            ".error"))    base::try({    }        callr_data <- base::as.environment("tools:callr")$`__callr_data__`}, interrupt = function(e) {        pxlib <- callr_data$pxlib    {        if (base::is.null(e$code)) {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`            e$code <- "301"        err <- callr_data$err        }        if (FALSE) {        msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e,             base::assign(".Traceback", base::.traceback(4), envir = callr_data)            NULL)))            utils::dump.frames("__callr_dump__")
  > test_loo_and_waic.R:         data <- base::paste0(e$code, " ", base::nchar(msg), "\n",             base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,                 envir = callr_data)            msg)        if (callr_data$has_otel) {            callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code))        }            base::rm("__callr_dump__", envir = .GlobalEnv)        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"))) {        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)            base::invokeRestart("muffleMessage")        cut <- base::which(e2$trace$scope == "global")[1]        }        if (!base::is.na(cut)) {    })            e2$trace <- e2$trace[-(1:cut), ]})        }
  > test_loo_and_waic.R:         if (callr_data$has_otel) {59:             callr_data$otel_span$record_exception(e2)doTryCatch(return(expr), name, parentenv, handler)        }
  > test_loo_and_waic.R:         base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268", 60:             ".error"))tryCatchOne(expr, names, parentenv, handlers[[1L]])    }
  > test_loo_and_waic.R: }, callr_message = function(e) {61:     base::try({tryCatchList(expr, names[-nh], parentenv, handlers[-nh])        callr_data <- base::as.environment("tools:callr")$`__callr_data__`
  > test_loo_and_waic.R:         pxlib <- callr_data$pxlib62:         if (base::is.null(e$code)) {doTryCatch(return(expr), name, parentenv, handler)            e$code <- "301"
  > test_loo_and_waic.R:         }63:         msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e, tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),             NULL)))    names[nh], parentenv, handlers[[nh]])        data <- base::paste0(e$code, " ", base::nchar(msg), "\n", 
  > test_loo_and_waic.R:             msg)64:         if (callr_data$has_otel) {tryCatchList(expr, classes, parentenv, handlers)            callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code))
  > test_loo_and_waic.R:         }65:         pxlib$write_fd(3L, data)base::tryCatch(base::withCallingHandlers({        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"))) {    {        NULL        NULL    }    base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),             base::invokeRestart("muffleMessage")        base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         }        quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",     })        compress = FALSE)})    base::flush(base::stdout())
  > test_loo_and_waic.R:     base::flush(base::stderr())59:     {doTryCatch(return(expr), name, parentenv, handler)        NULL
  > test_loo_and_waic.R:         NULL60:     }tryCatchOne(expr, names, parentenv, handlers[[1L]])    base::invisible()
  > test_loo_and_waic.R: }, error = function(e) {61:     {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        err <- callr_data$err        if (FALSE) {tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  > test_loo_and_waic.R: 62: doTryCatch(return(expr), name, parentenv, handler)
  > 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)            base::rm("__callr_dump__", envir = .GlobalEnv)63:         }tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),         e <- err$process_call(e)    names[nh], parentenv, handlers[[nh]])        e2 <- err$new_error("error in callr subprocess")
  > test_loo_and_waic.R:         class <- base::class64:         class(e2) <- base::c("callr_remote_error", class(e2))tryCatchList(expr, classes, parentenv, handlers)        e2 <- err$add_trace_back(e2)
  > test_loo_and_waic.R:         cut <- base::which(e2$trace$scope == "global")[1]65:         if (!base::is.na(cut)) {base::tryCatch(base::withCallingHandlers({            e2$trace <- e2$trace[-(1:cut), ]    {        }        NULL        if (callr_data$has_otel) {        NULL            callr_data$otel_span$record_exception(e2)    }        }    base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b20639c4647"),         base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,             ".error"))        quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         compress = FALSE)    base::flush(base::stdout())    base::flush(base::stderr())    {    }        NULL}, interrupt = function(e) {        NULL    {    }        callr_data <- base::as.environment("tools:callr")$`__callr_data__`    base::invisible()        err <- callr_data$err}, error = function(e) {        if (FALSE) {    {            base::assign(".Traceback", base::.traceback(4), envir = callr_data)        callr_data <- base::as.environment("tools:callr")$`__callr_data__`            utils::dump.frames("__callr_dump__")        err <- callr_data$err            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,         if (FALSE) {                envir = callr_data)            base::assign(".Traceback", base::.traceback(4), envir = callr_data)            base::rm("__callr_dump__", envir = .GlobalEnv)            utils::dump.frames("__callr_dump__")        }            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,         e <- err$process_call(e)                envir = callr_data)        e2 <- err$new_error("error in callr subprocess")            base::rm("__callr_dump__", envir = .GlobalEnv)        class <- base::class        }        class(e2) <- base::c("callr_remote_error", class(e2))        e <- err$process_call(e)        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        if (!base::is.na(cut)) {        class(e2) <- base::c("callr_remote_error", class(e2))            e2$trace <- e2$trace[-(1:cut), ]        e2 <- err$add_trace_back(e2)        }        cut <- base::which(e2$trace$scope == "global")[1]        if (callr_data$has_otel) {        if (!base::is.na(cut)) {            callr_data$otel_span$record_exception(e2)            e2$trace <- e2$trace[-(1:cut), ]        }        }        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",         if (callr_data$has_otel) {            ".error"))            callr_data$otel_span$record_exception(e2)    }        }}, callr_message = function(e) {        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2028ca1268",     base::try({            ".error"))        callr_data <- base::as.environment("tools:callr")$`__callr_data__`    }        pxlib <- callr_data$pxlib}, interrupt = function(e) {        if (base::is.null(e$code)) {    {            e$code <- "301"        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        }        err <- callr_data$err        msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e,         if (FALSE) {            NULL)))            base::assign(".Traceback", base::.traceback(4), envir = callr_data)        data <- base::paste0(e$code, " ", base::nchar(msg), "\n",             utils::dump.frames("__callr_dump__")            msg)            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,         if (callr_data$has_otel) {                envir = callr_data)            base::rm("__callr_dump__", envir = .GlobalEnv)        }
  > test_loo_and_waic.R:             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))    }        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/RtmpnQV3fP/callr-rs-result-13b2028ca1268",     if (FALSE) {        base::q(save = "no", status = 1)    }            ".error"))    }}, callr_message = function(e) {    base::try({        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        pxlib <- callr_data$pxlib    base::invisible()        if (base::is.null(e$code)) {}, interrupt = function(e) {    {        NULL        NULL    }    if (FALSE) {        base::q(save = "no", status = 1)            e$code <- "301"    }    base::invisible()})
  > test_loo_and_waic.R:         }        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) {An irrecoverable exception occurred. R is aborting now ...
  > test_loo_and_waic.R:             callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code))        }        pxlib$write_fd(3L, data)        if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) {            base::invokeRestart("cli_message_handled")        }        else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {            base::invokeRestart("muffleMessage")        }    })}), error = function(e) {    {        NULL        NULL    }    if (FALSE) {        base::try(base::stop(e))    }    if (FALSE) {        base::q(save = "no", status = 1)    }    base::invisible()}, interrupt = function(e) {    {        NULL        NULL    }    if (FALSE) {        base::q(save = "no", status = 1)    }    base::invisible()})
  > test_loo_and_waic.R: An irrecoverable exception occurred. R is aborting now ...
  Saving _problems/test_loo_and_waic-30.R
  > test_loo_predictive_metric.R: 
  > test_loo_predictive_metric.R:  *** caught segfault ***
  > test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
  > test_loo_predictive_metric.R: 
  > test_loo_predictive_metric.R:  *** caught segfault ***
  > test_loo_predictive_metric.R: address 0x110, cause 'invalid permissions'
  > test_loo_predictive_metric.R: 
  > test_loo_predictive_metric.R: Traceback:
  > test_loo_predictive_metric.R:  1: outer(X, Y)
  > test_loo_predictive_metric.R:  2: -theta %o% x
  > test_loo_predictive_metric.R:  3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
  > test_loo_predictive_metric.R:  4: psis_smooth_tail(lw_tail, cutoff)
  > test_loo_predictive_metric.R:  5: is_fun(log_ratios_i = log_ratios[, i], tail_len_i = tail_len[i])
  > test_loo_predictive_metric.R:  6: FUN(X[[i]], ...)
  > test_loo_predictive_metric.R:  7: lapply(X = S, FUN = FUN, ...)
  > test_loo_predictive_metric.R:  8: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R:  9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 10: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
  > test_loo_predictive_metric.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
  > test_loo_predictive_metric.R: 13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
  > test_loo_predictive_metric.R: 14: FUN(X[[i]], ...)
  > test_loo_predictive_metric.R: 15: lapply(seq_len(cores), inner.do)
  > test_loo_predictive_metric.R: 16: parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[,     i], tail_len_i = tail_len[i]))
  > test_loo_predictive_metric.R: 17: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores,     method = method)
  > test_loo_predictive_metric.R: 18: importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores,     method = "psis")
  > test_loo_predictive_metric.R: 19: psis.matrix(-LL, r_eff = r_eff, cores = 2)
  > test_loo_predictive_metric.R: 20: psis(-LL, r_eff = r_eff, cores = 2)
  > test_loo_predictive_metric.R: 21: eval(code, test_env)
  > test_loo_predictive_metric.R: 22: eval(code, test_env)
  > test_loo_predictive_metric.R: 23: withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE    invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message,     error = handle_error, interrupt = handle_interrupt)
  > test_loo_predictive_metric.R: 24: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 26: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 27: tryCatch(withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE    invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message,     error = handle_error, interrupt = handle_interrupt), error = handle_fatal)
  > test_loo_predictive_metric.R: 28: doWithOneRestart(return(expr), restart)
  > test_loo_predictive_metric.R: 29: withOneRestart(expr, restarts[[1L]])
  > test_loo_predictive_metric.R: 30: withRestarts(tryCatch(withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {        skip(paste0("{", e$package, "} is not installed."))    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE
  > test_loo_predictive_metric.R: Traceback:
  > test_loo_predictive_metric.R:  1: outer(X, Y)
  > test_loo_predictive_metric.R:  2:     invokeRestart("muffle_cran_snapshot")}, skip = handle_skip, warning = handle_warning, message = handle_message,     error = handle_error, interrupt = handle_interrupt), error = handle_fatal),     end_test = function() {    })
  > test_loo_predictive_metric.R: 31: -theta %o% x
  > test_loo_predictive_metric.R:  3: posterior::gpdfit(exp(x) - exp_cutoff, sort_x = FALSE)
  > test_loo_predictive_metric.R: test_code(code = exprs, env = env, reporter = get_reporter() %||%     StopReporter$new())
  > test_loo_predictive_metric.R: 32: source_file(path, env = env(env), desc = desc, shuffle = shuffle,  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:     error_call = error_call)
  > test_loo_predictive_metric.R: 33: test_one_file(path, env = the$testing_env, shuffle = shuffle)
  > test_loo_predictive_metric.R: 34: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: 35:  8: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R:  9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 36: tryCatchList(expr, classes, parentenv, handlers)
  > 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))
  > test_loo_predictive_metric.R: 39: asNamespace("testthat")$queue_task(path, shuffle)
  > test_loo_predictive_metric.R: 40: (function (path, shuffle) {    asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE))
  > test_loo_predictive_metric.R: 41: 10: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 11: tryCatch(expr, error = function(e) {(function (what, args, quote = FALSE, envir = parent.frame()) {    if (!is.list(args))         stop("second argument must be a list")    if (quote)         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_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/RtmpnQV3fP/callr-fun-13b206568e26c"),     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     quote = TRUE)
  > test_loo_predictive_metric.R: 43: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b206568e26c"),     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",     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/RtmpnQV3fP/callr-fun-13b206568e26c"),         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",         compress = FALSE)    base::flush(base::stdout())    base::flush(base::stderr())    {        NULL        NULL    }    base::invisible()}, error = function(e) {    {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        err <- callr_data$err        if (FALSE) {            base::assign(".Traceback", base::.traceback(4), envir = callr_data)            utils::dump.frames("__callr_dump__")            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,                 envir = callr_data)            base::rm("__callr_dump__", envir = .GlobalEnv)        }        e <- err$process_call(e)        e2 <- err$new_error("error in callr subprocess")        class <- base::class        class(e2) <- base::c("callr_remote_error", class(e2))        e2 <- err$add_trace_back(e2)        cut <- base::which(e2$trace$scope == "global")[1]        if (!base::is.na(cut)) {            e2$trace <- e2$trace[-(1:cut), ]        }        if (callr_data$has_otel) {            callr_data$otel_span$record_exception(e2)        }        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".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)    call <- conditionCall(e)
  > test_loo_predictive_metric.R:     if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        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))        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]
  > test_loo_predictive_metric.R: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
  > test_loo_predictive_metric.R: 13:         if (!base::is.na(cut)) {            e2$trace <- e2$trace[-(1:cut), ]        }        if (callr_data$has_otel) {            callr_data$otel_span$record_exception(e2)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
  > test_loo_predictive_metric.R: 14: FUN(X[[i]], ...)
  > test_loo_predictive_metric.R: 15: lapply(seq_len(cores), inner.do)
  > test_loo_predictive_metric.R: 16:         }parallel::mclapply(X = seq_len(N), mc.cores = cores, FUN = function(i) is_fun(log_ratios_i = log_ratios[,     i], tail_len_i = tail_len[i]))
  > test_loo_predictive_metric.R: 17: do_importance_sampling(log_ratios, r_eff = r_eff, cores = cores,     method = method)
  > test_loo_predictive_metric.R: 18: importance_sampling.matrix(log_ratios, ..., r_eff = r_eff, cores = cores,     method = "psis")
  > test_loo_predictive_metric.R: 19: psis.matrix(-LL, r_eff = r_eff, cores = 2)
  > test_loo_predictive_metric.R: 20: psis(-LL, r_eff = r_eff, cores = 2)
  > test_loo_predictive_metric.R:         base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".error"))    }21: eval(code, test_env)
  > test_loo_predictive_metric.R: 22: eval(code, test_env)
  > test_loo_predictive_metric.R: 23: withCallingHandlers({}, callr_message = function(e) {    base::try({        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        pxlib <- callr_data$pxlib    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }        if (base::is.null(e$code)) {            e$code <- "301"        }        msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e,             NULL)))}, 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)        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"))) {
  > test_loo_predictive_metric.R: 24: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])            base::invokeRestart("cli_message_handled")        }        else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {            base::invokeRestart("muffleMessage")        }    })
  > test_loo_predictive_metric.R: 26: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 27: })
  > test_loo_predictive_metric.R: 45: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: tryCatch(withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations    if (snapshot_skipped) {        skip("On CRAN")46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 47: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  > test_loo_predictive_metric.R:     }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    if (on_cran()) {48:         skip(paste0("{", e$package, "} is not installed."))doTryCatch(return(expr), name, parentenv, handler)    }}, snapshot_on_cran = function(cnd) {    snapshot_skipped <<- TRUE
  > test_loo_predictive_metric.R: 49: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  > test_loo_predictive_metric.R: 50:     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: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 51: base::tryCatch(base::withCallingHandlers({    {        NULLwithOneRestart(expr, restarts[[1L]])
  > test_loo_predictive_metric.R: 30: withRestarts(tryCatch(withCallingHandlers({    eval(code, test_env)    new_expectations <- the$test_expectations > starting_expectations        NULL    }    base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b206568e26c"),         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",     if (snapshot_skipped) {        compress = FALSE)        skip("On CRAN")    }    else if (!new_expectations && skip_on_empty) {        skip_empty()    }}, expectation = handle_expectation, packageNotFoundError = function(e) {    base::flush(base::stdout())    base::flush(base::stderr())    {        NULL        NULL    }    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_predictive_metric.R:     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__")31:             base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, test_code(code = exprs, env = env, reporter = get_reporter() %||%                 envir = callr_data)    StopReporter$new())
  > test_loo_predictive_metric.R: 32: source_file(path, env = env(env), desc = desc, shuffle = shuffle,     error_call = error_call)            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)) {
  > test_loo_predictive_metric.R:             e2$trace <- e2$trace[-(1:cut), ]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:         }        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/RtmpnQV3fP/callr-rs-result-13b2048e95477", 35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 36: tryCatchList(expr, classes, parentenv, handlers)            ".error"))    }}, interrupt = function(e) {    {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        err <- callr_data$err
  > test_loo_predictive_metric.R: 37: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL        if (FALSE) {            base::assign(".Traceback", base::.traceback(4), envir = callr_data)            utils::dump.frames("__callr_dump__")            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`, })
  > test_loo_predictive_metric.R: 38: 
  > test_loo_predictive_metric.R:                 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/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".error"))    }}, callr_message = function(e) {    base::try({with_reporter(multi, test_one_file(path, env = the$testing_env,         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) {    shuffle = shuffle))
  > test_loo_predictive_metric.R: 39: asNamespace("testthat")$queue_task(path, shuffle)
  > test_loo_predictive_metric.R: 40:             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")        }(function (path, shuffle) {    asNamespace("testthat")$queue_task(path, shuffle)})(base::quote("test_loo_predictive_metric.R"), base::quote(FALSE))
  > test_loo_predictive_metric.R: 41:         else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {            base::invokeRestart("muffleMessage")        }    })}), error = function(e) {    {        NULL(function (what, args, quote = FALSE, envir = parent.frame()) {    if (!is.list(args))         stop("second argument must be a list")    if (quote)         args <- lapply(args, enquote)        NULL    }    if (FALSE) {        base::try(base::stop(e))    }    if (FALSE) {        base::q(save = "no", status = 1)    }    base::invisible()}, interrupt = function(e) {    .Internal(do.call(what, args, envir))})(base::quote(function (path, shuffle) {    asNamespace("testthat")$queue_task(path, shuffle)}), base::quote(list("test_loo_predictive_metric.R", FALSE)),     envir = base::quote(<environment>), quote = base::quote(TRUE))
  > test_loo_predictive_metric.R:     {42:         NULL        NULL    }    if (FALSE) {        base::q(save = "no", status = 1)    }base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b206568e26c"),     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     quote = TRUE)
  > test_loo_predictive_metric.R: 43:     base::invisible()})
  > test_loo_predictive_metric.R: An irrecoverable exception occurred. R is aborting now ...
  > test_loo_predictive_metric.R: base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b206568e26c"),     base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,     quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",     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/RtmpnQV3fP/callr-fun-13b206568e26c"),         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",         compress = FALSE)    base::flush(base::stdout())    base::flush(base::stderr())    {        NULL        NULL    }    base::invisible()}, error = function(e) {    {        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        err <- callr_data$err        if (FALSE) {            base::assign(".Traceback", base::.traceback(4), envir = callr_data)            utils::dump.frames("__callr_dump__")            base::assign(".Last.dump", .GlobalEnv$`__callr_dump__`,                 envir = callr_data)            base::rm("__callr_dump__", envir = .GlobalEnv)        }        e <- err$process_call(e)        e2 <- err$new_error("error in callr subprocess")        class <- base::class        class(e2) <- base::c("callr_remote_error", class(e2))        e2 <- err$add_trace_back(e2)        cut <- base::which(e2$trace$scope == "global")[1]        if (!base::is.na(cut)) {            e2$trace <- e2$trace[-(1:cut), ]        }        if (callr_data$has_otel) {            callr_data$otel_span$record_exception(e2)        }        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".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/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".error"))    }}, callr_message = function(e) {    base::try({        callr_data <- base::as.environment("tools:callr")$`__callr_data__`        pxlib <- callr_data$pxlib        if (base::is.null(e$code)) {            e$code <- "301"        }        msg <- base::paste0("base64::", pxlib$base64_encode(base::serialize(e,             NULL)))        data <- base::paste0(e$code, " ", base::nchar(msg), "\n",             msg)        if (callr_data$has_otel) {            callr_data$otel_span$add_event("callr message", attributes = list(status_code = e$code))        }        pxlib$write_fd(3L, data)        if (base::inherits(e, "cli_message") && !base::is.null(base::findRestart("cli_message_handled"))) {            base::invokeRestart("cli_message_handled")        }        else if (base::inherits(e, "message") && !base::is.null(base::findRestart("muffleMessage"))) {            base::invokeRestart("muffleMessage")        }    })})
  > test_loo_predictive_metric.R: 45: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: 46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  > test_loo_predictive_metric.R: 47: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  > test_loo_predictive_metric.R: 48: doTryCatch(return(expr), name, parentenv, handler)
  > test_loo_predictive_metric.R: 49: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  > test_loo_predictive_metric.R: 50: tryCatchList(expr, classes, parentenv, handlers)
  > test_loo_predictive_metric.R: 51: base::tryCatch(base::withCallingHandlers({    {        NULL        NULL    }    base::saveRDS(base::do.call(base::do.call, base::c(base::readRDS("/Volumes/Temp/tmp/RtmpnQV3fP/callr-fun-13b206568e26c"),         base::list(envir = .GlobalEnv, quote = TRUE)), envir = .GlobalEnv,         quote = TRUE), file = "/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",         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)        }
  > test_loo_predictive_metric.R:         e <- err$process_call(e)        e2 <- err$new_error("error in callr subprocess")        class <- base::class        class(e2) <- base::c("callr_remote_error", class(e2))        e2 <- err$add_trace_back(e2)        cut <- base::which(e2$trace$scope == "global")[1]        if (!base::is.na(cut)) {            e2$trace <- e2$trace[-(1:cut), ]        }        if (callr_data$has_otel) {            callr_data$otel_span$record_exception(e2)        }        base::saveRDS(base::list("error", e2, e), file = base::paste0("/Volumes/Temp/tmp/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".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/RtmpnQV3fP/callr-rs-result-13b2048e95477",             ".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