Running ‘testthat.R’ [36s/57s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(patrick)
  > library(bit64)
  [1mThe assignment of character values to integer64 vectors and matrices with automatic coercion to integer64 will change to a more R consistent behaviour of coercing to character in future versions of bit64. If you wish you can update your code to the new behaviour by setting the option 'bit64.promoteInteger64ToCharacter' to TRUE.[22m
  
  Attaching package: 'bit64'
  
  The following object is masked from 'package:utils':
  
      hashtab
  
  The following objects are masked from 'package:base':
  
      %in%, :, array, as.factor, as.ordered, colSums, factor, intersect,
      is.double, is.element, match, matrix, order, rank, rowSums,
      setdiff, setequal, table, union
  
  > 
  > test_check("bit64")
  1 000000000000000000000000000000000000000000000000000000000000001
  0 111111111111111111111111111111111111111111111111111111111111111
  
   *** caught segfault ***
  address 0x55e4ffed8f50, cause 'memory not mapped'
  
  Traceback:
   1: shellsort.integer64(y, decreasing = decreasing, na.last = na.last)
   2: sort_function(y, decreasing = decreasing, na.last = na.last)
   3: eval_bare(expr, quo_get_env(quo))
   4: quasi_label(enquo(object), label)
   5: expect_identical(sort_function(y, decreasing = decreasing, na.last = na.last),     n_missing)
   6: eval_tidy(code, test_args)
   7: eval(code, test_env)
   8: eval(code, test_env)
   9: 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)
  10: doTryCatch(return(expr), name, parentenv, handler)
  11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  12: tryCatchList(expr, classes, parentenv, handlers)
  13: 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)
  14: doWithOneRestart(return(expr), restart)
  15: withOneRestart(expr, restarts[[1L]])
  16: 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    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() {    })
  17: test_code(code, parent.frame())
  18: test_that(completed_desc, eval_tidy(code, test_args))
  19: withCallingHandlers(test_that(completed_desc, eval_tidy(code,     test_args)), testthat_braces_warning = cnd_muffle)
  20: .f(sort_function = .l[[1L]][[i]], na.last = .l[[2L]][[i]], decreasing = .l[[3L]][[i]],     duplicates = .l[[4L]][[i]], n_missing = .l[[5L]][[i]], .test_name = .l[[6L]][[i]],     ...)
  21: .Primitive(".Call")(list(name = "pmap_impl", address = <pointer: 0x55e4f8c4e110>,     dll = list(name = "purrr", path = "/home/hornik/tmp/R.check/r-devel-clang/Work/build/Packages/purrr/libs/purrr.so",         dynamicLookup = FALSE, handle = <pointer: 0x55e4f90c1790>,         info = <pointer: 0x55e4f95d1c70>, forceSymbols = FALSE),     numParameters = 8L), <environment>, "list", FALSE, 120L,     NULL, 5L, c("sort_function", "na.last", "decreasing", "duplicates",     "n_missing", ".test_name"), 6L)
  22: call_with_cleanup(pmap_impl, environment(), .type, .progress,     n, names, i, call_names, call_n)
  23: withCallingHandlers(expr, error = function(cnd) {    if (i == 0L) {    }    else {        message <- c(i = "In index: {i}.")        if (!is.null(names) && !is.na(names[[i]]) && names[[i]] !=             "") {            name <- names[[i]]            message <- c(message, i = "With name: {name}.")        }        else {            name <- NULL        }        cli::cli_abort(message, location = i, name = name, parent = cnd,             call = error_call, class = "purrr_error_indexed")    }})
  24: with_indexed_errors(i = i, names = names, error_call = .purrr_error_call,     call_with_cleanup(pmap_impl, environment(), .type, .progress,         n, names, i, call_names, call_n))
  25: pmap_("list", .l, .f, ..., .progress = .progress)
  26: pmap(all_pars, build_and_run_test, desc = desc_stub, code = captured,     .interpret_glue = .interpret_glue)
  27: with_parameters_test_that("sorting methods for integer64 work",     {        withr::local_options(list(bit64.warn.exported.s3.method = FALSE))        x = as.integer64(1:10)        na_entries = rep(NA_integer64_, n_missing)        y = sample(c(x, if (duplicates) x[1L], na_entries))        expect_identical(sort_function(y, decreasing = decreasing,             na.last = na.last), n_missing)        expected_value = c(if (na.last) integer64() else na_entries,             if (duplicates && !decreasing) x[1L], if (decreasing) rev(x) else x,             if (duplicates && decreasing) x[1L], if (na.last) na_entries else integer64())        expect_identical(y, expected_value)    }, .cases = expand.grid(sort_function = list(bit::mergesort,         bit::quicksort, bit::radixsort, bit::ramsort, bit::shellsort),         na.last = c(FALSE, TRUE), decreasing = c(FALSE, TRUE),         duplicates = c(FALSE, TRUE), n_missing = 0:2))
  28: eval(code, test_env)
  29: eval(code, test_env)
  30: 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)
  31: doTryCatch(return(expr), name, parentenv, handler)
  32: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  33: tryCatchList(expr, classes, parentenv, handlers)
  34: 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)
  35: doWithOneRestart(return(expr), restart)
  36: withOneRestart(expr, restarts[[1L]])
  37: 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    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() {    })
  38: test_code(code = exprs, env = env, reporter = get_reporter() %||%     StopReporter$new())
  39: source_file(path, env = env(env), desc = desc, shuffle = shuffle,     error_call = error_call)
  40: FUN(X[[i]], ...)
  41: lapply(test_paths, test_one_file, env = env, desc = desc, shuffle = shuffle,     error_call = error_call)
  42: doTryCatch(return(expr), name, parentenv, handler)
  43: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  44: tryCatchList(expr, classes, parentenv, handlers)
  45: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
  46: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, desc = desc, shuffle = shuffle, error_call = error_call))
  47: test_files_serial(test_dir = test_dir, test_package = test_package,     test_paths = test_paths, load_helpers = load_helpers, reporter = reporter,     env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,     desc = desc, load_package = load_package, shuffle = shuffle,     error_call = error_call)
  48: test_files(test_dir = path, test_paths = test_paths, test_package = package,     reporter = reporter, load_helpers = load_helpers, env = env,     stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,     load_package = load_package, parallel = parallel, shuffle = shuffle)
  49: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  50: test_check("bit64")
  An irrecoverable exception occurred. R is aborting now ...
  Segmentation fault