CRAN Package Check Results for Package BIEN

Last updated on 2022-01-06 15:51:13 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 1.2.4 29.76 310.51 340.27 ERROR
r-devel-linux-x86_64-debian-gcc 1.2.4 25.36 231.76 257.12 ERROR
r-devel-linux-x86_64-fedora-clang 1.2.4 426.35 ERROR
r-devel-linux-x86_64-fedora-gcc 1.2.4 404.45 ERROR
r-devel-windows-x86_64-new-UL 1.2.4 92.00 161.00 253.00 NOTE --no-examples --no-tests --no-vignettes
r-devel-windows-x86_64-new-TK 1.2.4 ERROR
r-patched-linux-x86_64 1.2.4 26.77 270.96 297.73 ERROR
r-release-linux-x86_64 1.2.4 33.00 267.77 300.77 ERROR
r-release-macos-arm64 1.2.4 NOTE
r-release-macos-x86_64 1.2.4 NOTE
r-release-windows-ix86+x86_64 1.2.4 70.00 254.00 324.00 NOTE --no-examples --no-tests --no-vignettes
r-oldrel-macos-x86_64 1.2.4 OK
r-oldrel-windows-ix86+x86_64 1.2.4 72.00 263.00 335.00 OK --no-examples --no-tests --no-vignettes

Additional issues

M1mac

Check Details

Version: 1.2.4
Check: LazyData
Result: NOTE
     'LazyData' is specified without a 'data' directory
Flavors: r-devel-linux-x86_64-debian-clang, r-devel-linux-x86_64-debian-gcc, r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-devel-windows-x86_64-new-TK, r-patched-linux-x86_64, r-release-linux-x86_64, r-release-macos-arm64, r-release-macos-x86_64

Version: 1.2.4
Check: tests
Result: ERROR
     Running 'testthat.R' [11s/19s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
    
     *** caught segfault ***
     address 0x12, cause 'memory not mapped'
    
     Traceback:
     1: postgresqlExecStatement(conn, statement, ...)
     2: dbSendQuery(con, statement, ...)
     3: dbSendQuery(con, statement, ...)
     4: doTryCatch(return(expr), name, parentenv, handler)
     5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     6: tryCatchList(expr, classes, parentenv, handlers)
     7: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
     8: try(dbSendQuery(con, statement, ...))
     9: postgresqlQuickSQL(conn, statement, ...)
     10: dbGetQuery(con, statement = query)
     11: dbGetQuery(con, statement = query)
     12: .BIEN_sql(query, ...)
     13: BIEN_list_country("Bahamas", schema = schema)
     14: eval_bare(expr, quo_get_env(quo))
     15: quasi_label(enquo(object), label, arg = "object")
     16: expect_is(x, class)
     17: condition(object)
     18: expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame"))
     19: eval(code, test_env)
     20: eval(code, test_env)
     21: 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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     28: 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) { })
     29: test_code(desc, code, env = parent.frame(), reporter = reporter)
     30: test_that("List functions return a dataframe", { expect_that(BIEN_list_all(schema = schema), is_a("data.frame")) expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame")) expect_that(BIEN_list_county(country = "United States", state = "Michigan", county = "Kent", cultivated = T, only.new.world = F, schema = schema), is_a("data.frame")) expect_that(BIEN_list_state(country = "United States", state = "Rhode Island", schema = schema), is_a("data.frame"))})
     31: eval(code, test_env)
     32: eval(code, test_env)
     33: 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)
     34: doTryCatch(return(expr), name, parentenv, handler)
     35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     36: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     37: doTryCatch(return(expr), name, parentenv, handler)
     38: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     39: tryCatchList(expr, classes, parentenv, handlers)
     40: 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) { })
     41: test_code(NULL, exprs, env)
     42: source_file(path, child_env(env), wrap = wrap)
     43: FUN(X[[i]], ...)
     44: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     45: doTryCatch(return(expr), name, parentenv, handler)
     46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     47: tryCatchList(expr, classes, parentenv, handlers)
     48: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})
     49: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     50: 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)
     51: 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)
     52: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     53: test_check("BIEN")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavors: r-devel-linux-x86_64-debian-clang, r-release-linux-x86_64

Version: 1.2.4
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
     ...
    --- re-building 'BIEN.Rmd' using rmarkdown
    --- finished re-building 'BIEN.Rmd'
    
    --- re-building 'BIEN_tutorial.Rmd' using knitr
    Loading required package: RPostgreSQL
    Loading required package: DBI
    Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
    Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
    
     *** caught segfault ***
    address 0x11, cause 'memory not mapped'
    
    Traceback:
     1: postgresqlExecStatement(conn, statement, ...)
     2: dbSendQuery(con, statement, ...)
     3: dbSendQuery(con, statement, ...)
     4: doTryCatch(return(expr), name, parentenv, handler)
     5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     6: tryCatchList(expr, classes, parentenv, handlers)
     7: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
     8: try(dbSendQuery(con, statement, ...))
     9: postgresqlQuickSQL(conn, statement, ...)
    10: dbGetQuery(con, statement = query)
    11: dbGetQuery(con, statement = query)
    12: .BIEN_sql(query, ...)
    13: BIEN_list_country(country = "Bahamas")
    14: eval(expr, envir, enclos)
    15: eval(expr, envir, enclos)
    16: withVisible(eval(expr, envir, enclos))
    17: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)
    18: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler))
    19: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    20: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, debug = debug, last = i == length(out), use_try = stop_on_error != 2L, keep_warning = keep_warning, keep_message = keep_message, output_handler = output_handler, include_timing = include_timing)
    21: evaluate::evaluate(...)
    22: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else { if (options$error && options$include) 0L else 2L }, output_handler = knit_handlers(options$render, options))
    23: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else { if (options$error && options$include) 0L else 2L }, output_handler = knit_handlers(options$render, options)))
    24: eng_r(options)
    25: block_exec(params)
    26: call_block(x)
    27: process_group.block(group)
    28: process_group(group)
    29: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), error = function(e) { setwd(wd) cat(res, sep = "\n", file = output %n% "") message("Quitting from lines ", paste(current_lines(i), collapse = "-"), " (", knit_concord$get("infile"), ") ") })
    30: process_file(text, output)
    31: knit(input, text = text, envir = envir, quiet = quiet)
    32: (if (grepl("\\.[Rr]md$", file)) knit2html else if (grepl("\\.[Rr]rst$", file)) knit2pandoc else knit)(file, encoding = encoding, quiet = quiet, envir = globalenv(), ...)
    33: engine$weave(file, quiet = quiet, encoding = enc)
    34: doTryCatch(return(expr), name, parentenv, handler)
    35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    36: tryCatchList(expr, classes, parentenv, handlers)
    37: tryCatch({ engine$weave(file, quiet = quiet, encoding = enc) setwd(startdir) output <- find_vignette_product(name, by = "weave", engine = engine) if (!have.makefile && vignette_is_tex(output)) { texi2pdf(file = output, clean = FALSE, quiet = quiet) output <- find_vignette_product(name, by = "texi2pdf", engine = engine) } outputs <- c(outputs, output)}, error = function(e) { thisOK <<- FALSE fails <<- c(fails, file) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", file, conditionMessage(e)))})
    38: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-clang/Work/PKGS/BIEN.Rcheck/vign_test/BIEN")
    An irrecoverable exception occurred. R is aborting now ...
    Segmentation fault
Flavor: r-devel-linux-x86_64-debian-clang

Version: 1.2.4
Check: tests
Result: ERROR
     Running ‘testthat.R’ [8s/19s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
    
     *** caught segfault ***
     address 0x12, cause 'memory not mapped'
    
     Traceback:
     1: postgresqlExecStatement(conn, statement, ...)
     2: dbSendQuery(con, statement, ...)
     3: dbSendQuery(con, statement, ...)
     4: doTryCatch(return(expr), name, parentenv, handler)
     5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     6: tryCatchList(expr, classes, parentenv, handlers)
     7: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
     8: try(dbSendQuery(con, statement, ...))
     9: postgresqlQuickSQL(conn, statement, ...)
     10: dbGetQuery(con, statement = query)
     11: dbGetQuery(con, statement = query)
     12: .BIEN_sql(query, ...)
     13: BIEN_list_country("Bahamas", schema = schema)
     14: eval_bare(expr, quo_get_env(quo))
     15: quasi_label(enquo(object), label, arg = "object")
     16: expect_is(x, class)
     17: condition(object)
     18: expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame"))
     19: eval(code, test_env)
     20: eval(code, test_env)
     21: 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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     28: 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) { })
     29: test_code(desc, code, env = parent.frame(), reporter = reporter)
     30: test_that("List functions return a dataframe", { expect_that(BIEN_list_all(schema = schema), is_a("data.frame")) expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame")) expect_that(BIEN_list_county(country = "United States", state = "Michigan", county = "Kent", cultivated = T, only.new.world = F, schema = schema), is_a("data.frame")) expect_that(BIEN_list_state(country = "United States", state = "Rhode Island", schema = schema), is_a("data.frame"))})
     31: eval(code, test_env)
     32: eval(code, test_env)
     33: 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)
     34: doTryCatch(return(expr), name, parentenv, handler)
     35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     36: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     37: doTryCatch(return(expr), name, parentenv, handler)
     38: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     39: tryCatchList(expr, classes, parentenv, handlers)
     40: 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) { })
     41: test_code(NULL, exprs, env)
     42: source_file(path, child_env(env), wrap = wrap)
     43: FUN(X[[i]], ...)
     44: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     45: doTryCatch(return(expr), name, parentenv, handler)
     46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     47: tryCatchList(expr, classes, parentenv, handlers)
     48: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})
     49: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     50: 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)
     51: 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)
     52: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     53: test_check("BIEN")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 1.2.4
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
     ...
    --- re-building ‘BIEN.Rmd’ using rmarkdown
    --- finished re-building ‘BIEN.Rmd’
    
    --- re-building ‘BIEN_tutorial.Rmd’ using knitr
    Loading required package: RPostgreSQL
    Loading required package: DBI
    Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
    Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
    
     *** caught segfault ***
    address 0x11, cause 'memory not mapped'
    
    Traceback:
     1: postgresqlExecStatement(conn, statement, ...)
     2: dbSendQuery(con, statement, ...)
     3: dbSendQuery(con, statement, ...)
     4: doTryCatch(return(expr), name, parentenv, handler)
     5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     6: tryCatchList(expr, classes, parentenv, handlers)
     7: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
     8: try(dbSendQuery(con, statement, ...))
     9: postgresqlQuickSQL(conn, statement, ...)
    10: dbGetQuery(con, statement = query)
    11: dbGetQuery(con, statement = query)
    12: .BIEN_sql(query, ...)
    13: BIEN_list_country(country = "Bahamas")
    14: eval(expr, envir, enclos)
    15: eval(expr, envir, enclos)
    16: withVisible(eval(expr, envir, enclos))
    17: withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)
    18: handle(ev <- withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler))
    19: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval(expr, envir, enclos)), warning = wHandler, error = eHandler, message = mHandler)))
    20: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, debug = debug, last = i == length(out), use_try = stop_on_error != 2L, keep_warning = keep_warning, keep_message = keep_message, output_handler = output_handler, include_timing = include_timing)
    21: evaluate::evaluate(...)
    22: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else { if (options$error && options$include) 0L else 2L }, output_handler = knit_handlers(options$render, options))
    23: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else { if (options$error && options$include) 0L else 2L }, output_handler = knit_handlers(options$render, options)))
    24: eng_r(options)
    25: block_exec(params)
    26: call_block(x)
    27: process_group.block(group)
    28: process_group(group)
    29: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), error = function(e) { setwd(wd) cat(res, sep = "\n", file = output %n% "") message("Quitting from lines ", paste(current_lines(i), collapse = "-"), " (", knit_concord$get("infile"), ") ") })
    30: process_file(text, output)
    31: knit(input, text = text, envir = envir, quiet = quiet)
    32: (if (grepl("\\.[Rr]md$", file)) knit2html else if (grepl("\\.[Rr]rst$", file)) knit2pandoc else knit)(file, encoding = encoding, quiet = quiet, envir = globalenv(), ...)
    33: engine$weave(file, quiet = quiet, encoding = enc)
    34: doTryCatch(return(expr), name, parentenv, handler)
    35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    36: tryCatchList(expr, classes, parentenv, handlers)
    37: tryCatch({ engine$weave(file, quiet = quiet, encoding = enc) setwd(startdir) output <- find_vignette_product(name, by = "weave", engine = engine) if (!have.makefile && vignette_is_tex(output)) { texi2pdf(file = output, clean = FALSE, quiet = quiet) output <- find_vignette_product(name, by = "texi2pdf", engine = engine) } outputs <- c(outputs, output)}, error = function(e) { thisOK <<- FALSE fails <<- c(fails, file) message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", file, conditionMessage(e)))})
    38: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/BIEN.Rcheck/vign_test/BIEN")
    An irrecoverable exception occurred. R is aborting now ...
    Segmentation fault
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 1.2.4
Check: tests
Result: ERROR
     Running ‘testthat.R’ [21s/104s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<07>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<07>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<07>)
     ══ Failed tests ════════════════════════════════════════════════════════════════
     ── Failure (test-BIEN.r:10:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:10:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:11:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:11:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:12:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:12:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
    
     [ FAIL 3 | WARN 3 | SKIP 0 | PASS 18 ]
     Error: Test failures
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 1.2.4
Check: tests
Result: ERROR
     Running ‘testthat.R’ [21s/114s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<07>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<04>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<03>)
     ══ Failed tests ════════════════════════════════════════════════════════════════
     ── Failure (test-BIEN.r:10:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:10:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:11:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:11:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:12:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:12:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
    
     [ FAIL 3 | WARN 3 | SKIP 0 | PASS 18 ]
     Error: Test failures
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 1.2.4
Flags: --no-examples --no-tests --no-vignettes
Check: LazyData
Result: NOTE
     'LazyData' is specified without a 'data' directory
Flavors: r-devel-windows-x86_64-new-UL, r-release-windows-ix86+x86_64

Version: 1.2.4
Check: tests
Result: ERROR
     Running 'testthat.R'
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<c0><0c>c<04>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<c0><0c>c<04>)
     Error in postgresqlExecStatement(conn, statement, ...) :
     RS-DBI driver: (<c0><0c>c<04>)
     ══ Failed tests ════════════════════════════════════════════════════════════════
     ── Failure (test-BIEN.r:10:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:10:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:11:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:11:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
     ── Failure (test-BIEN.r:12:1): List functions return a dataframe ───────────────
     `x` inherits from `'NULL'` not `'character'`.
     Backtrace:
     █
     1. └─testthat::expect_that(...) test-BIEN.r:12:0
     2. └─testthat:::condition(object)
     3. └─testthat::expect_is(x, class)
    
     [ FAIL 3 | WARN 3 | SKIP 0 | PASS 18 ]
     Error: Test failures
     Execution halted
Flavor: r-devel-windows-x86_64-new-TK

Version: 1.2.4
Check: re-building of vignette outputs
Result: WARN
    Error(s) in re-building vignettes:
    --- re-building 'BIEN.Rmd' using rmarkdown
    --- finished re-building 'BIEN.Rmd'
    
    --- re-building 'BIEN_tutorial.Rmd' using knitr
    Loading required package: RPostgreSQL
    Loading required package: DBI
    Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
    Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
    Quitting from lines 430-434 (BIEN_tutorial.Rmd)
    Error: processing vignette 'BIEN_tutorial.Rmd' failed with diagnostics:
    input string 1 is invalid UTF-8
    --- failed re-building 'BIEN_tutorial.Rmd'
    
    SUMMARY: processing the following file failed:
     'BIEN_tutorial.Rmd'
    
    Error: Vignette re-building failed.
    Execution halted
Flavor: r-devel-windows-x86_64-new-TK

Version: 1.2.4
Check: tests
Result: ERROR
     Running ‘testthat.R’ [11s/22s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > #Tests for BIEN package
     >
     > library(testthat)
     > library(BIEN)
     Loading required package: RPostgreSQL
     Loading required package: DBI
     Type vignette("BIEN") or vignette("BIEN_tutorial") to get started
     Showtime, Synergy! The BIEN database has been updated to version 4.2! Functions should still work the same, but may now return different records due to the incorporation of more records and updated validations.
     > test_check("BIEN")
    
     *** caught segfault ***
     address 0x12, cause 'memory not mapped'
    
     Traceback:
     1: postgresqlExecStatement(conn, statement, ...)
     2: dbSendQuery(con, statement, ...)
     3: dbSendQuery(con, statement, ...)
     4: doTryCatch(return(expr), name, parentenv, handler)
     5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     6: tryCatchList(expr, classes, parentenv, handlers)
     7: tryCatch(expr, error = function(e) { call <- conditionCall(e) if (!is.null(call)) { if (identical(call[[1L]], quote(doTryCatch))) call <- sys.call(-4L) dcall <- deparse(call, nlines = 1L) prefix <- paste("Error in", dcall, ": ") LONG <- 75L sm <- strsplit(conditionMessage(e), "\n")[[1L]] w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") if (is.na(w)) w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], type = "b") if (w > LONG) prefix <- paste0(prefix, "\n ") } else prefix <- "Error : " msg <- paste0(prefix, conditionMessage(e), "\n") .Internal(seterrmessage(msg[1L])) if (!silent && isTRUE(getOption("show.error.messages"))) { cat(msg, file = outFile) .Internal(printDeferredWarnings()) } invisible(structure(msg, class = "try-error", condition = e))})
     8: try(dbSendQuery(con, statement, ...))
     9: postgresqlQuickSQL(conn, statement, ...)
     10: dbGetQuery(con, statement = query)
     11: dbGetQuery(con, statement = query)
     12: .BIEN_sql(query, ...)
     13: BIEN_list_country("Bahamas", schema = schema)
     14: eval_bare(expr, quo_get_env(quo))
     15: quasi_label(enquo(object), label, arg = "object")
     16: expect_is(x, class)
     17: condition(object)
     18: expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame"))
     19: eval(code, test_env)
     20: eval(code, test_env)
     21: 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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     28: 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) { })
     29: test_code(desc, code, env = parent.frame(), reporter = reporter)
     30: test_that("List functions return a dataframe", { expect_that(BIEN_list_all(schema = schema), is_a("data.frame")) expect_that(BIEN_list_country("Bahamas", schema = schema), is_a("data.frame")) expect_that(BIEN_list_county(country = "United States", state = "Michigan", county = "Kent", cultivated = T, only.new.world = F, schema = schema), is_a("data.frame")) expect_that(BIEN_list_state(country = "United States", state = "Rhode Island", schema = schema), is_a("data.frame"))})
     31: eval(code, test_env)
     32: eval(code, test_env)
     33: 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)
     34: doTryCatch(return(expr), name, parentenv, handler)
     35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     36: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     37: doTryCatch(return(expr), name, parentenv, handler)
     38: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     39: tryCatchList(expr, classes, parentenv, handlers)
     40: 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) { })
     41: test_code(NULL, exprs, env)
     42: source_file(path, child_env(env), wrap = wrap)
     43: FUN(X[[i]], ...)
     44: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     45: doTryCatch(return(expr), name, parentenv, handler)
     46: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     47: tryCatchList(expr, classes, parentenv, handlers)
     48: tryCatch(code, testthat_abort_reporter = function(cnd) { cat(conditionMessage(cnd), "\n") NULL})
     49: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     50: 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)
     51: 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)
     52: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     53: test_check("BIEN")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavor: r-patched-linux-x86_64