Running ‘testthat.R’ [33s/56s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(odin)
  > 
  > test_check("odin")
  [ FAIL 1 | WARN 0 | SKIP 18 | PASS 1066 ]
  
  ══ Skipped tests ═══════════════════════════════════════════════════════════════
  • Engine is r (3)
  • On CRAN (15)
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error (test-interface.R:8:3): verbose ───────────────────────────────────────
  <system_command_status_error/system_command_error/rlib_error_2_0/rlib_error/error/condition>
  Error in `(function (command = NULL, args = character(), error_on_status = TRUE, 
      wd = NULL, echo_cmd = FALSE, echo = FALSE, spinner = FALSE, 
      timeout = Inf, stdout = "|", stderr = "|", stdout_line_callback = NULL, 
      stdout_callback = NULL, stderr_line_callback = NULL, stderr_callback = NULL, 
      stderr_to_stdout = FALSE, env = NULL, windows_verbatim_args = FALSE, 
      windows_hide_window = FALSE, encoding = "", cleanup_tree = FALSE, 
      ...) 
  {
      assert_that(is_flag(error_on_status))
      assert_that(is_time_interval(timeout))
      assert_that(is_flag(spinner))
      assert_that(is_string_or_null(stdout))
      assert_that(is_string_or_null(stderr))
      assert_that(is.null(stdout_line_callback) || is.function(stdout_line_callback))
      assert_that(is.null(stderr_line_callback) || is.function(stderr_line_callback))
      assert_that(is.null(stdout_callback) || is.function(stdout_callback))
      assert_that(is.null(stderr_callback) || is.function(stderr_callback))
      assert_that(is_flag(cleanup_tree))
      assert_that(is_flag(stderr_to_stdout))
      "!DEBUG run() Checked arguments"
      if (!interactive()) 
          spinner <- FALSE
      if (stderr_to_stdout) 
          stderr <- "2>&1"
      pr <- process$new(command, args, echo_cmd = echo_cmd, wd = wd, 
          windows_verbatim_args = windows_verbatim_args, windows_hide_window = windows_hide_window, 
          stdout = stdout, stderr = stderr, env = env, encoding = encoding, 
          cleanup_tree = cleanup_tree, ...)
      "#!DEBUG run() Started the process: `pr$get_pid()`"
      if (cleanup_tree) {
          on.exit(pr$kill_tree(), add = TRUE)
      }
      else {
          on.exit(pr$kill(), add = TRUE)
      }
      if (echo) {
          stdout_callback <- echo_callback(stdout_callback, "stdout")
          stderr_callback <- echo_callback(stderr_callback, "stderr")
      }
      runcall <- sys.call()
      resenv <- new.env(parent = emptyenv())
      has_stdout <- !is.null(stdout) && stdout == "|"
      has_stderr <- !is.null(stderr) && stderr == "|"
      if (has_stdout) {
          resenv$outbuf <- make_buffer()
          on.exit(resenv$outbuf$done(), add = TRUE)
      }
      if (has_stderr) {
          resenv$errbuf <- make_buffer()
          on.exit(resenv$errbuf$done(), add = TRUE)
      }
      res <- tryCatch(run_manage(pr, timeout, spinner, stdout, 
          stderr, stdout_line_callback, stdout_callback, stderr_line_callback, 
          stderr_callback, resenv), interrupt = function(e) {
          "!DEBUG run() process `pr$get_pid()` killed on interrupt"
          out <- if (has_stdout) {
              resenv$outbuf$push(pr$read_output())
              resenv$outbuf$push(pr$read_output())
              resenv$outbuf$read()
          }
          err <- if (has_stderr) {
              resenv$errbuf$push(pr$read_error())
              resenv$errbuf$push(pr$read_error())
              resenv$errbuf$read()
          }
          tryCatch(pr$kill(), error = function(e) NULL)
          signalCondition(new_process_interrupt_cond(list(interrupt = TRUE, 
              stderr = err, stdout = out, command = command, args = args), 
              runcall, echo = echo, stderr_to_stdout = stderr_to_stdout))
          cat("\n")
          invokeRestart("abort")
      })
      if (error_on_status && (is.na(res$status) || res$status != 
          0)) {
          "!DEBUG run() error on status `res$status` for process `pr$get_pid()`"
          throw(new_process_error(res, call = sys.call(), echo = echo, 
              stderr_to_stdout, res$status, command = command, 
              args = args))
      }
      res
  })("/home/hornik/tmp/R.check/r-devel-gcc/Work/build/bin/R", args = c("CMD", 
  "INSTALL", "/home/hornik/tmp/scratch/RtmpsZPkYF/file2414fe68c2504b", 
  "--library=/home/hornik/tmp/scratch/RtmpsZPkYF/devtools_install_2414fe21a58766", 
  "--no-R", "--no-data", "--no-help", "--no-demo", "--no-inst", 
  "--no-docs", "--no-exec", "--no-multiarch", "--no-test-load"), 
      stdout_line_callback = function (x, proc) 
      {
          if (!is.null(stream)) 
              cat(x, file = stream, sep = "\n", append = TRUE)
      }, stderr_line_callback = function (x, proc) 
      {
          if (!is.null(stream)) 
              cat(x, file = stream, sep = "\n", append = TRUE)
      }, stdout_callback = function (x, proc) 
      block_cb(x), stderr_callback = function (x, proc) 
      block_cb(x), stderr_to_stdout = TRUE, echo_cmd = FALSE, echo = FALSE, 
      spinner = FALSE, error_on_status = TRUE, timeout = structure(Inf, class = "difftime", units = "secs"))`: System command 'R' failed, exit status: 1, stdout & stderr were printed
  Backtrace:
       ▆
    1. ├─testthat::expect_output(...) at test-interface.R:8:2
    2. │ └─testthat:::quasi_capture(...)
    3. │   ├─testthat .capture(...)
    4. │   │ └─testthat::capture_output_lines(code, print, width = width)
    5. │   │   └─testthat:::eval_with_output(code, print = print, width = width)
    6. │   │     ├─withr::with_output_sink(path, withVisible(code))
    7. │   │     │ └─base::force(code)
    8. │   │     └─base::withVisible(code)
    9. │   └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
   10. ├─odin::odin(...)
   11. │ └─odin::odin_(...)
   12. │   └─odin:::odin_generate(ir, options)
   13. │     └─odin:::odin_c_wrapper(ir, options)
   14. │       └─odin:::compile_dll(dest, compile_attributes = FALSE, quiet = quiet)
   15. │         └─pkgbuild::compile_dll(...)
   16. │           └─pkgbuild:::install_min(...)
   17. │             └─pkgbuild::rcmd_build_tools(...)
   18. │               ├─pkgbuild::with_build_tools(...)
   19. │               ├─base::withCallingHandlers(...)
   20. │               └─callr::rcmd_safe(...)
   21. │                 └─callr:::run_r(options)
   22. │                   ├─base::with(...)
   23. │                   └─base::with.default(...)
   24. │                     └─base::eval(substitute(expr), data, enclos = parent.frame())
   25. │                       └─base::eval(substitute(expr), data, enclos = parent.frame())
   26. │                         ├─callr:::with_envvar(...)
   27. │                         │ └─base::force(code)
   28. │                         ├─base::do.call(...)
   29. │                         └─processx `<fn>`(...)
   30. │                           └─throw(...)
   31. │                             └─base::signalCondition(cond)
   32. └─pkgbuild `<fn>`(`<systm___>`)
   33.   └─asNamespace("callr")$err$throw(e)
  
  [ FAIL 1 | WARN 0 | SKIP 18 | PASS 1066 ]
  Error: Test failures
  Execution halted