Running ‘run.R’
  Running ‘scaling.R’
Running the tests in ‘tests/run.R’ failed.
Complete output:
  > # Run tests
  > 
  > library(testthat)
  > library(covr)
  > library(diffobj)
  > 
  > local({                                         # so we can use `on.exit`
  +   # options that can't be reset to NULL...
  + 
  +   no.null.opts <- c(
  +     "warnPartialMatchArgs", "warnPartialMatchAttr", "warnPartialMatchDollar"
  +   )
  +   no.null.opt.list <- Map(getOption, no.null.opts)
  +   no.null.nulls <- vapply(no.null.opt.list, is.null, logical(1L))
  +   no.null.opt.list[no.null.nulls] <- FALSE
  +   all.opts <- c(
  +     list(
  +       useFancyQuotes=FALSE,   # all.equals uses fancy quotes
  +       diffobj.format="ansi8", # force ANSI colors
  +       diffobj.color.mode="yb",# force yb
  +       diffobj.pager="off",    # run tests without pager
  +       width=80L,
  +       encoding="UTF-8"        # so Gabor's name renders properly on win...
  +     )
  +   )
  +   old.opts <- options(c(diffobj_set_def_opts(), all.opts))
  +   options(
  +     warnPartialMatchArgs=TRUE,
  +     warnPartialMatchAttr=TRUE,
  +     warnPartialMatchDollar=TRUE
  +   )
  +   old.opts <- c(old.opts, no.null.opt.list)
  + 
  +   # covr options have no effect here; just recorded so we can use them ahead
  +   # of calling package_coverage() when running tests manually
  +   if(FALSE) {
  +     options(covr.exclude_start="(?://|#)[[:space:]]*nocov[[:space:]]*start")
  +     options(covr.exclude_end="(?://|#)[[:space:]]*nocov[[:space:]]*end")
  +     options(covr.exclude_pattern="(?://|#)[[:space:]]*nocov")
  +   }
  +   on.exit(options(old.opts))
  +   test.res <- test_dir(
  +     "testthat",
  +     filter=paste0(                              # so we can run subset of files
  +       c(
  +         "atomic",
  +         "banner",
  +         "capture",
  +         "check",
  +         "context",
  +         "core",
  +         "diffChr",
  +         "diffDeparse",
  +         "diffObj",
  +         "diffPrint",
  +         "diffStr",
  +         "file",
  +         "guide",
  +         "html",
  +         "limit",
  +         "methods",
  +         "misc",
  +         "pager",
  +         "rdiff",
  +         "s4",
  +         "style",
  +         "subset",
  +         "summary",
  +         "text",
  +         "trim",
  +         "warning"
  +       ), collapse="|"
  +     )
  +   )
  +   with(
  +     as.data.frame(test.res), {
  +       fail <- sum(failed)
  +       err <- sum(error)
  +       if(fail != 0 || err) stop("Errors: ", err, " Failures: ", fail)
  +   })
  + })
  Atomic: 123456
  banner: 7
  capture: ..
  check: .......................8
  Context: 9a
  core: b......................
  diffChr: cdefEE
  diffDeparse: E
  diffObj: EEError in vapply(rle.elig, max, integer(1L)) : 
    values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  Calls: local ... as.list.environment -> par_frame -> which_top -> vapply
  
  Failed -------------------------------------------------------------------------
  1. Error: Basic Tests (@testthat.atomic.R#12) ----------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(chr.1, chr.2)), rdsf(100)) at testthat/testthat.atomic.R:12
  2: compare(object, reference, ...)
  3: diffPrint(chr.1, chr.2)
  4: diffPrint(chr.1, chr.2)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  2. Error: Word wrap in atomic (@testthat.atomic.R#50) --------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(A[-(1:8)], A)), rdsf(900)) at testthat/testthat.atomic.R:50
  2: compare(object, reference, ...)
  3: diffPrint(A[-(1:8)], A)
  4: diffPrint(A[-(1:8)], A)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  3. Error: with names (@testthat.atomic.R#122) ----------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(F, G)), rdsf(2300)) at testthat/testthat.atomic.R:122
  2: compare(object, reference, ...)
  3: diffPrint(F, G)
  4: diffPrint(F, G)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  4. Error: Original tests (@testthat.atomic.R#149) ------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(w1, w2)), rdsf(2600)) at testthat/testthat.atomic.R:149
  2: compare(object, reference, ...)
  3: diffPrint(w1, w2)
  4: diffPrint(w1, w2)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  5. Error: Simple word diffs (@testthat.atomic.R#156) ---------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(a, b)), rdsf(2900)) at testthat/testthat.atomic.R:156
  2: compare(object, reference, ...)
  3: diffPrint(a, b)
  4: diffPrint(a, b)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  6. Error: Alignment edge cases (@testthat.atomic.R#167) ------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffPrint(20:50, 30:62)), rdsf(3200)) at testthat/testthat.atomic.R:167
  2: compare(object, reference, ...)
  3: diffPrint(20:50, 30:62)
  4: diffPrint(20:50, 30:62)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  7. Error: Banner Capture (@testthat.banner.R#5) --------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: diffPrint(1 + 2, letters, tar.banner = "1 + 2", cur.banner = "letters") at testthat/testthat.banner.R:5
  2: diffPrint(1 + 2, letters, tar.banner = "1 + 2", cur.banner = "letters")
  3: .local(target, current, ...)
  4: par_frame()
  5: which_top(s.c)
  6: vapply(rle.elig, max, integer(1L))
  
  8. Failure: valid_object (@testthat.check.R#48) --------------------------------
  error$message does not match "`palette.of.styles` is an invalid".
  Actual value: "values must be type 'integer',\n but FUN(X[[1]]) result is type 'double'"
  
  
  9. Error: interesting context values (@testthat.context.R#11) ------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(chr.9, chr.10, context = 0)), rdsf(100)) at testthat/testthat.context.R:11
  2: compare(object, reference, ...)
  3: diffChr(chr.9, chr.10, context = 0)
  4: diffChr(chr.9, chr.10, context = 0)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  10. Error: with line limit (@testthat.context.R#29) ----------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(chr.9, chr.10, context = "auto", line.limit = 18)), 
         rdsf(400)) at testthat/testthat.context.R:29
  2: compare(object, reference, ...)
  3: diffChr(chr.9, chr.10, context = "auto", line.limit = 18)
  4: diffChr(chr.9, chr.10, context = "auto", line.limit = 18)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  11. Error: diff myers simple (@testthat.core.R#11) -----------------------------
  is.integer(path) is not TRUE
  1: expect_identical(diffobj:::myers_simple(character(), character()), list(target = integer(0), 
         current = integer(0))) at testthat/testthat.core.R:11
  2: identical(object, expected)
  3: diffobj:::myers_simple(character(), character())
  4: diff_path_to_diff(path, target, current)
  5: stopifnot(is.character(target), is.character(current), is.matrix(path), is.integer(path), 
         ncol(path) == 2, all(path[, 1L] %in% c(0L, seq_along(target))), all(path[, 2L] %in% 
             c(0L, seq_along(current))))
  6: stop(msg, call. = FALSE, domain = NA)
  
  12. Error: Corner Cases (@testthat.diffChr.R#16) -------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(A1, B1)), rdsf(100)) at testthat/testthat.diffChr.R:16
  2: compare(object, reference, ...)
  3: diffChr(A1, B1)
  4: diffChr(A1, B1)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  13. Error: Larger strings (@testthat.diffChr.R#35) -----------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(chr.7, chr.8)), rdsf(300)) at testthat/testthat.diffChr.R:35
  2: compare(object, reference, ...)
  3: diffChr(chr.7, chr.8)
  4: diffChr(chr.7, chr.8)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  14. Error: Sentences (@testthat.diffChr.R#60) ----------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(chr.5, chr.6)), rdsf(400)) at testthat/testthat.diffChr.R:60
  2: compare(object, reference, ...)
  3: diffChr(chr.5, chr.6)
  4: diffChr(chr.5, chr.6)
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  15. Error: Whitespace (@testthat.diffChr.R#69) ---------------------------------
  values must be type 'integer',
   but FUN(X[[1]]) result is type 'double'
  1: expect_equal_to_reference(as.character(diffChr(c("a", "b", "c"), c("a ", "b", "c"))), 
         rdsf(800)) at testthat/testthat.diffChr.R:69
  2: compare(object, reference, ...)
  3: diffChr(c("a", "b", "c"), c("a ", "b", "c"))
  4: diffChr(c("a", "b", "c"), c("a ", "b", "c"))
  5: .local(target, current, ...)
  6: par_frame()
  7: which_top(s.c)
  8: vapply(rle.elig, max, integer(1L))
  
  DONE ===========================================================================
  Execution halted