Running ‘testthat.R’ [12s/14s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > 
  > test_check("dynutils")
  Loading required package: dynutils
  
  Attaching package: 'dynutils'
  
  The following object is masked from 'package:testthat':
  
      has_names
  
  
   *** caught segfault ***
  address 0x90000004f, cause 'memory not mapped'
  
  Traceback:
   1: cpp_pair(mt1 = x, mt2 = y, method = match(method, c("ejaccard",     "edice", "hamman", "simple matching", "faith", "chisquared",     "kullback", "manhattan", "maximum", "canberra", "minkowski")),     rank = rank, limit = min_proxy, weight = weight, symm = symm,     drop0 = drop0)
   2: proxy(x, y, margin, method, p = p, drop0 = drop0, digits = digits)
   3: proxyC::dist(x = x, y = y, method = method, margin = 2)
   4: calculate_distance(x = x, y = y, method = method)
   5: eval(code, test_env)
   6: eval(code, test_env)
   7: 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)
   8: doTryCatch(return(expr), name, parentenv, handler)
   9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  10: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  11: doTryCatch(return(expr), name, parentenv, handler)
  12: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  13: tryCatchList(expr, classes, parentenv, handlers)
  14: 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) {    })
  15: test_code(desc, code, env = parent.frame(), reporter = reporter)
  16: test_that("calculate_distance works on matrices, data frames and sparse matrices",     {        x <- Matrix::rsparsematrix(100, 10000, 0.01)        y <- Matrix::rsparsematrix(2000, 10000, 0.01)        for (method in methods) {            out <- calculate_distance(x = x, y = y, method = method)            expect_equal(nrow(out), nrow(x))            expect_equal(ncol(out), nrow(y))            out2 <- calculate_distance(x = as.matrix(x), y = as.matrix(y),                 method = method)            expect_equal(nrow(out2), nrow(x))            expect_equal(ncol(out2), nrow(y))            expect_true(sum(abs(out2 - out)) < 1e-10)            out3 <- calculate_distance(x = as.data.frame(as.matrix(x)),                 y = as.data.frame(as.matrix(y)), method = method)            expect_equal(nrow(out3), nrow(x))            expect_equal(ncol(out3), nrow(y))            expect_true(sum(abs(out3 - out)) < 1e-10)        }    })
  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(NULL, exprs, env)
  28: source_file(path, child_env(env), wrap = wrap)
  29: FUN(X[[i]], ...)
  30: lapply(test_paths, test_one_file, env = env, wrap = wrap)
  31: force(code)
  32: doWithOneRestart(return(expr), restart)
  33: withOneRestart(expr, restarts[[1L]])
  34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  35: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, wrap = wrap))
  36: test_files(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)
  37: 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)
  38: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  39: test_check("dynutils")
  An irrecoverable exception occurred. R is aborting now ...
  
   *** caught segfault ***
  address 0x23000004ad, cause 'memory not mapped'
  
  Traceback:
   1: cpp_pair(mt1 = x, mt2 = y, method = match(method, c("ejaccard",     "edice", "hamman", "simple matching", "faith", "chisquared",     "kullback", "manhattan", "maximum", "canberra", "minkowski")),     rank = rank, limit = min_proxy, weight = weight, symm = symm,     drop0 = drop0)
   2: proxy(x, y, margin, method, p = p, drop0 = drop0, digits = digits)
   3: proxyC::dist(x = x, y = y, method = method, margin = 2)
   4: calculate_distance(x = x, y = y, method = method)
   5: eval(code, test_env)
   6: eval(code, test_env)
   7: 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)
   8: doTryCatch(return(expr), name, parentenv, handler)
   9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  10: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  11: doTryCatch(return(expr), name, parentenv, handler)
  12: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  13: tryCatchList(expr, classes, parentenv, handlers)
  14: 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) {    })
  15: test_code(desc, code, env = parent.frame(), reporter = reporter)
  16: test_that("calculate_distance works on matrices, data frames and sparse matrices",     {        x <- Matrix::rsparsematrix(100, 10000, 0.01)        y <- Matrix::rsparsematrix(2000, 10000, 0.01)        for (method in methods) {            out <- calculate_distance(x = x, y = y, method = method)            expect_equal(nrow(out), nrow(x))            expect_equal(ncol(out), nrow(y))            out2 <- calculate_distance(x = as.matrix(x), y = as.matrix(y),                 method = method)            expect_equal(nrow(out2), nrow(x))            expect_equal(ncol(out2), nrow(y))            expect_true(sum(abs(out2 - out)) < 1e-10)            out3 <- calculate_distance(x = as.data.frame(as.matrix(x)),                 y = as.data.frame(as.matrix(y)), method = method)            expect_equal(nrow(out3), nrow(x))            expect_equal(ncol(out3), nrow(y))            expect_true(sum(abs(out3 - out)) < 1e-10)        }    })
  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(NULL, exprs, env)
  28: source_file(path, child_env(env), wrap = wrap)
  29: FUN(X[[i]], ...)
  30: lapply(test_paths, test_one_file, env = env, wrap = wrap)
  31: force(code)
  32: doWithOneRestart(return(expr), restart)
  33: withOneRestart(expr, restarts[[1L]])
  34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  35: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, wrap = wrap))
  36: test_files(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)
  37: 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)
  38: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  39: test_check("dynutils")
  An irrecoverable exception occurred. R is aborting now ...
  Segmentation fault