Running ‘testthat.R’ [2s/11s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > test_check("ff")
  Loading required package: ff
  Loading required package: bit
  
  Attaching package: 'bit'
  
  The following object is masked from 'package:base':
  
      xor
  
  Attaching package ff
  - getOption("fftempdir")=="/tmp/RtmpWmmuXy/working_dir/RtmpX5OTM1/ff"
  
  - getOption("ffextension")=="ff"
  
  - getOption("ffdrop")==TRUE
  
  - getOption("fffinonexit")==TRUE
  
  - getOption("ffpagesize")==65536
  
  - getOption("ffcaching")=="mmnoflush"  -- consider "ffeachflush" if your system stalls on large writes
  
  - getOption("ffbatchbytes")==16777216 -- consider a different value for tuning your system
  
  - getOption("ffmaxbytes")==536870912 -- consider a different value for tuning your system
  
  
  Attaching package: 'ff'
  
  The following objects are masked from 'package:utils':
  
      write.csv, write.csv2
  
  The following objects are masked from 'package:base':
  
      is.factor, is.ordered
  
  
   *** caught segfault ***
  address 0x1, cause 'memory not mapped'
  
  Traceback:
   1: as.integer.bit(bit())
   2: as.integer(bit())
   3: eval_bare(expr, quo_get_env(quo))
   4: quasi_label(enquo(expected), expected.label, arg = "expected")
   5: expect_equal(b, as.integer(bit()))
   6: eval(code, test_env)
   7: eval(code, test_env)
   8: 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)
   9: doTryCatch(return(expr), name, parentenv, handler)
  10: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  11: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  12: doTryCatch(return(expr), name, parentenv, handler)
  13: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  14: tryCatchList(expr, classes, parentenv, handlers)
  15: 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) {    })
  16: test_code(desc, code, env = parent.frame(), default_reporter = local_interactive_reporter())
  17: test_that("Indexing functions can handle zero rows", {    b <- integer()    expect_equal(b, as.integer(bit()))    expect_equal(b, as.integer(as.hi(b)))    x <- as.ff(b)    expect_equal(length(x), 0)    expect_equal(vmode(x), "integer")    y <- as.ram(x)    expect_equal(length(x), 0)    expect_equal(vmode(x), "integer")    byte()    b <- as.byte(c())    expect_equal(length(b), 0)    expect_equal(class(b), "integer")    x <- as.ff(b)    expect_equal(length(x), 0)    expect_equal(vmode(x), "byte")    y <- as.ram(x)    expect_equal(length(y), 0)    expect_equal(vmode(y), "byte")    b <- bitwhich()    expect_equal(length(b), 0)    expect_equal(class(b), c("booltype", "bitwhich"))    expect_equal(b, as.bitwhich(NULL))    expect_equal(b, as.bitwhich(logical()))    expect_equal(as.hi(b), as.hi(NULL))    expect_equal(b, as.bitwhich(as.hi(b)))    b <- bit()    expect_equal(length(b), 0)    expect_equal(class(b), c("booltype", "bit"))    expect_equal(b, as.bit(NULL))    expect_equal(b, as.bit(logical()))    expect_equal(as.hi(b), as.hi(NULL))    expect_equal(b, as.bit(as.hi(b)))    x <- as.ff(b)    expect_equal(length(x), 0)    expect_equal(vmode(x), "boolean")    b <- logical()    expect_equal(b, as.logical(NULL))    expect_equal(b, as.logical(bit()))    expect_equal(length(b), 0)    expect_equal(as.hi(b), as.hi(NULL))    expect_equal(b, as.logical(as.hi(b)))    x <- as.ff(b)    expect_equal(length(x), 0)    expect_equal(vmode(x), "logical")    b <- as.which(integer(), maxindex = 0)    expect_equal(length(b), 0)    expect_equal(class(b), c("booltype", "which"))    expect_equal(b, as.which(bit()))    expect_equal(b, as.which(logical()))    expect_equal(as.hi(b), as.hi(NULL))    expect_equal(b, as.which(as.hi(b)))    x <- as.ff(b)    expect_equal(length(x), 0)    expect_equal(vmode(x), "integer")    h <- as.hi(NULL)    expect_equal(h, as.hi(as.which(integer(), maxindex = 0)))    expect_equal(h, as.hi(logical()))    expect_equal(h, as.hi(bit()))    expect_equal(h, as.hi(bitwhich()))    h$maxindex <- NA_integer_    expect_equal(h, as.hi(as.which(integer())))    expect_equal(h, as.hi(integer()))    expect_equal(h, as.hi(double()))    x <- as.ff(1:10)    y <- x[as.hi(NULL)]    expect_equal(vmode(x), vmode(y))    x <- as.integer(as.hi(c()))    expect_equal(length(x), 0)    expect_equal(class(x), "integer")    x <- as.vmode(c(), "double")    expect_equal(length(x), 0)    x <- as.vmode(c(), "logical")    expect_equal(length(x), 0)    x <- as.vmode(c(), "byte")    expect_equal(length(x), 0)    chunks <- chunk(ff(c()))    expect_equal(length(chunks), 0)    x <- data.frame(a = c(1, 2), b = c(2, 3))    x <- as.ffdf(x)    chunks <- chunk(x)    expect_equal(length(chunks), 1)    expect_equal(dimnames(x)[[2]], c("a", "b"))    ffdfsort(x)    x <- data.frame(a = c(1, 2), b = c(2, 3))    x <- x[x$a == 3, ]    x <- as.ffdf(x)    chunks <- chunk(x)    expect_equal(length(chunks), 0)    expect_equal(dimnames(x)[[2]], c("a", "b"))    ffdfsort(x)    expect_equal(nrow(x), 0)    x <- ff(c())    y <- ff(c())    x <- x[fforder(x, y)]    expect_equal(length(x), 0)    x <- ff(c())    x <- ffsort(x)    expect_equal(length(x), 0)})
  18: eval(code, test_env)
  19: eval(code, test_env)
  20: 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)
  21: doTryCatch(return(expr), name, parentenv, handler)
  22: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  23: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  24: doTryCatch(return(expr), name, parentenv, handler)
  25: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
  26: tryCatchList(expr, classes, parentenv, handlers)
  27: 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) {    })
  28: test_code(test = NULL, code = exprs, env = env, default_reporter = StopReporter$new())
  29: source_file(path, env = env(env), desc = desc, error_call = error_call)
  30: FUN(X[[i]], ...)
  31: lapply(test_paths, test_one_file, env = env, desc = desc, error_call = error_call)
  32: doTryCatch(return(expr), name, parentenv, handler)
  33: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  34: tryCatchList(expr, classes, parentenv, handlers)
  35: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
  36: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, desc = desc, error_call = error_call))
  37: 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, error_call = error_call)
  38: 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)
  39: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
  40: test_check("ff")
  An irrecoverable exception occurred. R is aborting now ...