Running ‘testthat.R’ [28s/75s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(mpathsenser)
  > 
  > test_check("mpathsenser")
  
  Attaching package: 'purrr'
  
  The following object is masked from 'package:testthat':
  
      is_null
  
  
   *** caught segfault ***
  address 0x555c00000001, cause 'memory not mapped'
  
  Traceback:
   1: base::options(...future.oldOptions)
   2: base::tryCatch({    base::withCallingHandlers({        ...future.value <- base::withVisible(base::local({            future_globals_max_size <- getOption("future.globals.maxSize")            if (!identical(future_globals_max_size, ...furrr_globals_max_size)) {                options(future.globals.maxSize = ...furrr_globals_max_size)                on.exit(options(future.globals.maxSize = future_globals_max_size),                   add = TRUE)            }            {                ...furrr_chunk_x <- ...furrr_chunk_args                {                  ...furrr_chunk_seeds_env <- environment()                  ...furrr_chunk_seeds_env[["i"]] <- 1L                }                NULL                ...furrr_fn_wrapper <- function(...) {                  {                    ...furrr_chunk_seeds_i <- ...furrr_chunk_seeds_env[["i"]]                    ...furrr_chunk_seeds_env[["i"]] <- ...furrr_chunk_seeds_i +                       1L                    assign(x = ".Random.seed", value = ...furrr_chunk_seeds[[...furrr_chunk_seeds_i]],                       envir = globalenv(), inherits = FALSE)                  }                  NULL                  ...furrr_out <- ...furrr_fn(...)                  ...furrr_out                }                args <- list(.x = ...furrr_chunk_x, .f = ...furrr_fn_wrapper)                args <- c(args, ...furrr_dots)                do.call(...furrr_map_fn, args)            }        }))        future::FutureResult(value = ...future.value$value, visible = ...future.value$visible,             rng = !identical(base::globalenv()$.Random.seed,                 ...future.rng), globalenv = if (FALSE)                 list(added = base::setdiff(base::names(base::.GlobalEnv),                   ...future.globalenv.names))            else NULL, started = ...future.startTime, version = "1.8")    }, condition = base::local({        c <- base::c        inherits <- base::inherits        invokeRestart <- base::invokeRestart        length <- base::length        list <- base::list        seq.int <- base::seq.int        signalCondition <- base::signalCondition        sys.calls <- base::sys.calls        `[[` <- base::`[[`        `+` <- base::`+`        `<<-` <- base::`<<-`        sysCalls <- function(calls = sys.calls(), from = 1L) {            calls[seq.int(from = from + 12L, to = length(calls) -                 3L)]        }        function(cond) {            is_error <- inherits(cond, "error")            ignore <- !is_error && !is.null(NULL) && inherits(cond,                 NULL)            if (is_error) {                sessionInformation <- function() {                  list(r = base::R.Version(), locale = base::Sys.getlocale(),                     rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(),                     search = base::search(), system = base::Sys.info())                }                ...future.conditions[[length(...future.conditions) +                   1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame),                   cond$call), session = sessionInformation(),                   timestamp = base::Sys.time(), signaled = 0L)                signalCondition(cond)            }            else if (!ignore && TRUE && inherits(cond, c("condition",             "immediateCondition"))) {                signal <- TRUE && inherits(cond, "immediateCondition")                ...future.conditions[[length(...future.conditions) +                   1L]] <<- list(condition = cond, signaled = base::as.integer(signal))                if (TRUE && !signal) {                  muffleCondition <- function (cond, pattern = "^muffle")                   {                    inherits <- base::inherits                    invokeRestart <- base::invokeRestart                    is.null <- base::is.null                    muffled <- FALSE                    if (inherits(cond, "message")) {                      muffled <- grepl(pattern, "muffleMessage")                      if (muffled)                         invokeRestart("muffleMessage")                    }                    else if (inherits(cond, "warning")) {                      muffled <- grepl(pattern, "muffleWarning")                      if (muffled)                         invokeRestart("muffleWarning")                    }                    else if (inherits(cond, "condition")) {                      if (!is.null(pattern)) {                        computeRestarts <- base::computeRestarts                        grepl <- base::grepl                        restarts <- computeRestarts(cond)                        for (restart in restarts) {                          name <- restart$name                          if (is.null(name))                             next                          if (!grepl(pattern, name))                             next                          invokeRestart(restart)                          muffled <- TRUE                          break                        }                      }                    }                    invisible(muffled)                  }                  muffleCondition(cond, pattern = "^muffle")                }            }            else {                if (TRUE) {                  muffleCondition <- function (cond, pattern = "^muffle")                   {                    inherits <- base::inherits                    invokeRestart <- base::invokeRestart                    is.null <- base::is.null                    muffled <- FALSE                    if (inherits(cond, "message")) {                      muffled <- grepl(pattern, "muffleMessage")                      if (muffled)                         invokeRestart("muffleMessage")                    }                    else if (inherits(cond, "warning")) {                      muffled <- grepl(pattern, "muffleWarning")                      if (muffled)                         invokeRestart("muffleWarning")                    }                    else if (inherits(cond, "condition")) {                      if (!is.null(pattern)) {                        computeRestarts <- base::computeRestarts                        grepl <- base::grepl                        restarts <- computeRestarts(cond)                        for (restart in restarts) {                          name <- restart$name                          if (is.null(name))                             next                          if (!grepl(pattern, name))                             next                          invokeRestart(restart)                          muffled <- TRUE                          break                        }                      }                    }                    invisible(muffled)                  }                  muffleCondition(cond, pattern = "^muffle")                }            }        }    }))}, error = function(ex) {    base::structure(base::list(value = NULL, visible = NULL,         conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed,             ...future.rng), started = ...future.startTime, finished = Sys.time(),         session_uuid = NA_character_, version = "1.8"), class = "FutureResult")}, finally = {    if (!identical(...future.workdir, getwd()))         setwd(...future.workdir)    {        if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {            ...future.oldOptions$nwarnings <- NULL        }        base::options(...future.oldOptions)        if (.Platform$OS.type == "windows") {            old_names <- names(...future.oldEnvVars)            envs <- base::Sys.getenv()            names <- names(envs)            common <- intersect(names, old_names)            added <- setdiff(names, old_names)            removed <- setdiff(old_names, names)            changed <- common[...future.oldEnvVars[common] !=                 envs[common]]            NAMES <- toupper(changed)            args <- list()            for (kk in seq_along(NAMES)) {                name <- changed[[kk]]                NAME <- NAMES[[kk]]                if (name != NAME && is.element(NAME, old_names))                   next                args[[name]] <- ...future.oldEnvVars[[name]]            }            NAMES <- toupper(added)            for (kk in seq_along(NAMES)) {                name <- added[[kk]]                NAME <- NAMES[[kk]]                if (name != NAME && is.element(NAME, old_names))                   next                args[[name]] <- ""            }            NAMES <- toupper(removed)            for (kk in seq_along(NAMES)) {                name <- removed[[kk]]                NAME <- NAMES[[kk]]                if (name != NAME && is.element(NAME, old_names))                   next                args[[name]] <- ...future.oldEnvVars[[name]]            }            if (length(args) > 0)                 base::do.call(base::Sys.setenv, args = args)            args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL        }        else {            base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))        }        {            if (base::length(...future.futureOptionsAdded) >                 0L) {                opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))                base::names(opts) <- ...future.futureOptionsAdded                base::options(opts)            }            {                {                  base::assign(".Random.seed", c(10407L, -428256819L,                   -1791747414L, -233216502L, 222641068L, -1783973573L,                   -1633342465L), envir = base::globalenv(), inherits = FALSE)                  NULL                }                options(future.plan = NULL)                if (is.na(NA_character_))                   Sys.unsetenv("R_FUTURE_PLAN")                else Sys.setenv(R_FUTURE_PLAN = NA_character_)                future::plan(list(function (..., envir = parent.frame())                 {                  future <- SequentialFuture(..., envir = envir)                  if (!future$lazy)                     future <- run(future)                  invisible(future)                }), .cleanup = FALSE, .init = FALSE)            }        }    }})
   3: eval(expr, envir = envir, enclos = baseenv())
   4: eval(expr, envir = envir, enclos = baseenv())
   5: run.UniprocessFuture(future)
   6: run(future)
   7: run.Future(future)
   8: run(future)
   9: future::future(expr, substitute = FALSE, envir = env_globals,     stdout = options$stdout, conditions = options$conditions,     globals = chunk_globals, packages = chunk_packages, seed = options$seed,     label = labels[[i]])
  10: furrr_template(args = x, fn = fn, dots = dots, n = n, options = options,     progress = progress, type = type, map_fn = map_fn, names = names,     env_globals = env_globals, expr = expr, extract = furrr_map_extract)
  11: furrr_map_template(x = .x, fn = .f, dots = list(...), options = .options,     progress = .progress, type = "list", map_fn = purrr::map,     env_globals = .env_globals)
  12: furrr::future_map(.x = batch_data, .f = .import_clean, .options = furrr::furrr_options(seed = TRUE))
  13: import(path, db = db, sensors = sensor, batch_size = 1, recursive = FALSE)
  14: withCallingHandlers(expr, message = function(c) if (inherits(c,     classes)) tryInvokeRestart("muffleMessage"))
  15: suppressMessages(import(path, db = db, sensors = sensor, batch_size = 1,     recursive = FALSE))
  16: db_test("Gyroscope", true_data = tibble::tibble(measurement_id = c("06bce1d4-b4a9-d1f1-2f06-cc76d872a61d_1",     paste0("ce0cc1bf-f071-91b5-19c8-4b3b789e64a2_", 1:5), "ce0cc1bf-f071-91b5-19c8-4b3b789e64a3",     "06bce1d4-b4a9-d1f1-2f06-cc76d872a61g", "6d8aa5b8-cd1b-c482-f678-5267c85b393b"),     participant_id = "12345", date = "2021-11-14", time = c("14:00:01.000",         "14:00:00.000", "14:00:00.200", "14:00:00.400", "14:00:00.600",         "14:00:00.800", "14:00:00.000", "14:00:01.000", "14:00:02.000"),     timezone = c(rep(NA, 6), "CET", NA, "CET"), x = c(NA, -0.000374194700270891,         -5.46156661584973e-05, 0.000158437062054873, 0.000158437062054873,         0.000158437062054873, -0.000374194700270891, NA, NA),     y = c(NA, -0.00320995226502419, -0.000600057013798505, -0.000173951615579426,         -0.000387004343792796, -0.000387004343792796, -0.00320995226502419,         NA, NA), z = c(NA, 0.0219468716531992, 0.000108967768028378,         0.000108967768028378, 0.000108967768028378, 0.000108967768028378,         0.0219468716531992, NA, NA), x_mean = c(rep(NA, 8), -1.00220812880809),     y_mean = c(rep(NA, 8), -2.00045008969199), z_mean = c(rep(NA,         8), -3.02347734926531), x_mean_sq = c(rep(NA, 8), 4.00002054091549),     y_mean_sq = c(rep(NA, 8), 5.00001809346463), z_mean_sq = c(rep(NA,         8), 6.00058290152449), n = c(rep(NA, 8), 299)))
  17: eval(code, test_env)
  18: eval(code, test_env)
  19: withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error)
  20: doTryCatch(return(expr), name, parentenv, handler)
  21: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  22: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  23: doTryCatch(return(expr), name, parentenv, handler)
  24: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  25: tryCatchList(expr, classes, parentenv, handlers)
  26: tryCatch(withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error), error = handle_fatal,     skip = function(e) {    })
  27: test_code(desc, code, env = parent.frame(), default_reporter = local_interactive_reporter())
  28: test_that("Gyroscope", {    db_test("Gyroscope", true_data = tibble::tibble(measurement_id = c("06bce1d4-b4a9-d1f1-2f06-cc76d872a61d_1",         paste0("ce0cc1bf-f071-91b5-19c8-4b3b789e64a2_", 1:5),         "ce0cc1bf-f071-91b5-19c8-4b3b789e64a3", "06bce1d4-b4a9-d1f1-2f06-cc76d872a61g",         "6d8aa5b8-cd1b-c482-f678-5267c85b393b"), participant_id = "12345",         date = "2021-11-14", time = c("14:00:01.000", "14:00:00.000",             "14:00:00.200", "14:00:00.400", "14:00:00.600", "14:00:00.800",             "14:00:00.000", "14:00:01.000", "14:00:02.000"),         timezone = c(rep(NA, 6), "CET", NA, "CET"), x = c(NA,             -0.000374194700270891, -5.46156661584973e-05, 0.000158437062054873,             0.000158437062054873, 0.000158437062054873, -0.000374194700270891,             NA, NA), y = c(NA, -0.00320995226502419, -0.000600057013798505,             -0.000173951615579426, -0.000387004343792796, -0.000387004343792796,             -0.00320995226502419, NA, NA), z = c(NA, 0.0219468716531992,             0.000108967768028378, 0.000108967768028378, 0.000108967768028378,             0.000108967768028378, 0.0219468716531992, NA, NA),         x_mean = c(rep(NA, 8), -1.00220812880809), y_mean = c(rep(NA,             8), -2.00045008969199), z_mean = c(rep(NA, 8), -3.02347734926531),         x_mean_sq = c(rep(NA, 8), 4.00002054091549), y_mean_sq = c(rep(NA,             8), 5.00001809346463), z_mean_sq = c(rep(NA, 8),             6.00058290152449), n = c(rep(NA, 8), 299)))})
  29: eval(code, test_env)
  30: eval(code, test_env)
  31: withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error)
  32: doTryCatch(return(expr), name, parentenv, handler)
  33: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  34: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  35: doTryCatch(return(expr), name, parentenv, handler)
  36: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  37: tryCatchList(expr, classes, parentenv, handlers)
  38: tryCatch(withCallingHandlers({    eval(code, test_env)    if (!handled && !is.null(test)) {        skip_empty()    }}, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,     message = handle_message, error = handle_error), error = handle_fatal,     skip = function(e) {    })
  39: test_code(test = NULL, code = exprs, env = env, default_reporter = StopReporter$new())
  40: source_file(path, env(env), wrap = wrap)
  41: FUN(X[[i]], ...)
  42: lapply(test_paths, test_one_file, env = env, wrap = wrap)
  43: doTryCatch(return(expr), name, parentenv, handler)
  44: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  45: tryCatchList(expr, classes, parentenv, handlers)
  46: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
  47: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, wrap = wrap))
  48: 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,     wrap = wrap, load_package = load_package)
  49: 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,     wrap = wrap, load_package = load_package, parallel = parallel)
  50: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  51: test_check("mpathsenser")
  An irrecoverable exception occurred. R is aborting now ...
  Segmentation fault