Running ‘testthat.R’ [5s/8s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library (testthat)
  > library (typetracer)
  > 
  > test_check ("typetracer")
  * installing *binary* package ‘rematch’ ...
  * DONE (rematch)
  * installing *binary* package ‘rematch’ ...
  * DONE (rematch)
  * installing *source* package ‘rematch’ ...
  ** this is package ‘rematch’ version ‘1.0.1’
  ** using non-staged installation
  ** R
  ** inst
  ** tests
  ** byte-compile and prepare package for lazy loading
  ** help
  *** installing help indices
    converting help for package ‘rematch’
      finding HTML links ... done
      re_match                                html  example
      re_match_all                            html  
      rematch                                 html  
  ** building package indices
  ** testing if installed package can be loaded
  * DONE (rematch)
  
   *** caught segfault ***
  address 0x28, cause 'memory not mapped'
  
  Traceback:
   1: eval(code, test_env)
   2: eval(code, test_env)
   3: 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)
   4: doTryCatch(return(expr), name, parentenv, handler)
   5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
   6: tryCatchList(expr, classes, parentenv, handlers)
   7: 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)
   8: doWithOneRestart(return(expr), restart)
   9: withOneRestart(expr, restarts[[1L]])
  10: 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() {    })
  11: test_code(code, parent.frame())
  12: test_that("corner cases", {    traces <- list.files("/home/hornik/tmp/scratch/Rtmp6yXN8V",         pattern = "^typetrace_", full.names = TRUE)    ntraces <- length(traces)    ftmp <- file.path("/home/hornik/tmp/scratch/Rtmp6yXN8V/R_LIBS2dbc8418dfb89a/rematch",         "tracetest_corner_cases.txt")    writeLines(as.character(ntraces), ftmp)    res <- re_match_all("", c("foo", "bar"))    expect_equal(res, list(cbind(.match = c("", "", "")), cbind(.match = c("",         "", ""))))    res <- re_match_all("", c("", "bar"))    expect_equal(res, list(cbind(.match = ""), cbind(.match = c("",         "", ""))))    res <- re_match_all("", character())    expect_equal(res, list())    res <- re_match_all("foo", character())    expect_equal(res, list())    res <- re_match_all("foo", "not")    expect_equal(res, list(cbind(.match = character())))})
  13: eval(code, test_env)
  14: eval(code, test_env)
  15: 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)
  16: doTryCatch(return(expr), name, parentenv, handler)
  17: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  18: tryCatchList(expr, classes, parentenv, handlers)
  19: 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)
  20: doWithOneRestart(return(expr), restart)
  21: withOneRestart(expr, restarts[[1L]])
  22: 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() {    })
  23: test_code(code = exprs, env = env, reporter = get_reporter() %||%     StopReporter$new())
  24: source_file(path, env = env(env), desc = desc, shuffle = shuffle,     error_call = error_call)
  25: FUN(X[[i]], ...)
  26: lapply(test_paths, test_one_file, env = env, desc = desc, shuffle = shuffle,     error_call = error_call)
  27: doTryCatch(return(expr), name, parentenv, handler)
  28: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  29: tryCatchList(expr, classes, parentenv, handlers)
  30: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
  31: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, desc = desc, shuffle = shuffle, error_call = error_call))
  32: 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)
  33: 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)
  34: test_dir(test_path, package = package, reporter = reporter, ...,     load_package = "installed")
  35: testthat::test_package(package, reporter = testthat::ListReporter)
  36: force(code)
  37: withr::with_dir(test_dir, testthat::test_package(package, reporter = testthat::ListReporter))
  38: trace_package_tests(package, pkg_dir, pre_installed)
  39: trace_package(package, pkg_dir = path, types = c("examples",     "tests"))
  40: eval_bare(expr, quo_get_env(quo))
  41: quasi_label(enquo(object))
  42: expect_s3_class(x0 <- trace_package(package, pkg_dir = path,     types = c("examples", "tests")), "tbl_df")
  43: eval(code, test_env)
  44: eval(code, test_env)
  45: 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)
  46: doTryCatch(return(expr), name, parentenv, handler)
  47: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  48: tryCatchList(expr, classes, parentenv, handlers)
  49: 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)
  50: doWithOneRestart(return(expr), restart)
  51: withOneRestart(expr, restarts[[1L]])
  52: 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() {    })
  53: test_code(code, parent.frame())
  54: test_that("trace source package", {    tarball <- testthat::test_path("..", "rematch_1.0.1.tar.gz")    tarball <- normalizePath(tarball)    skip_if(!file.exists(tarball))    if (utils::untar(tarball, exdir = tempdir(), tar = "internal") !=         0) {        stop("Unable to extract tarball to 'tempdir'")    }    package <- "rematch"    path <- normalizePath(file.path(tempdir(), package))    expect_s3_class(x0 <- trace_package(package, pkg_dir = path,         types = c("examples", "tests")), "tbl_df")    expect_true(nrow(x0) > 5)    expect_identical(names(x0), c("trace_number", "source_file_name",         "fn_name", "fn_call_hash", "call_env", "par_name", "class",         "typeof", "mode", "storage_mode", "length", "formal",         "uneval", "eval"))    expect_false(all(grepl("^rd_", x0$source_file_name)))    source_rd <- grep("\\.Rd$", x0$source_file_name, value = TRUE)    source_test <- grep("(^|\\.\\/)test", x0$source_file_name,         value = TRUE)    expect_true(length(source_rd) > 1L)    expect_true(length(source_test) > 1L)    expect_s3_class(x1 <- trace_package(package, pkg_dir = path,         types = c("examples", "tests"), functions = "re_match"),         "tbl_df")    expect_true(nrow(x1) < nrow(x0))})
  55: eval(code, test_env)
  56: eval(code, test_env)
  57: 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)
  58: doTryCatch(return(expr), name, parentenv, handler)
  59: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  60: tryCatchList(expr, classes, parentenv, handlers)
  61: 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)
  62: doWithOneRestart(return(expr), restart)
  63: withOneRestart(expr, restarts[[1L]])
  64: 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() {    })
  65: test_code(code = exprs, env = env, reporter = get_reporter() %||%     StopReporter$new())
  66: source_file(path, env = env(env), desc = desc, shuffle = shuffle,     error_call = error_call)
  67: FUN(X[[i]], ...)
  68: lapply(test_paths, test_one_file, env = env, desc = desc, shuffle = shuffle,     error_call = error_call)
  69: doTryCatch(return(expr), name, parentenv, handler)
  70: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  71: tryCatchList(expr, classes, parentenv, handlers)
  72: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
  73: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, desc = desc, shuffle = shuffle, error_call = error_call))
  74: 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)
  75: 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)
  76: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  77: test_check("typetracer")
  An irrecoverable exception occurred. R is aborting now ...
  Segmentation fault