Running ‘run.R’ [23s/27s]
Running the tests in ‘tests/run.R’ failed.
Complete output:
  > cat(getwd(), "\n")
  /home/ripley/R/packages/tests32/vetr.Rcheck/tests 
  > if(suppressWarnings(require('unitizer'))) {
  +   local({
  +     suppressWarnings(RNGversion("3.5.2"));
  +     on.exit({
  +       RNGversion(as.character(getRversion()))
  +     })
  +     pattern <- 'alike'
  +     unitize_dir(
  +       'unitizer',
  +       # pattern=pattern,
  +       state='recommended'
  +     )
  +   })
  + } else {
  +   warning("Cannot run tests without package `unitizer`")
  + }
  Loading required package: unitizer
  State tracking is disabled by default to comply with CRAN policies. Add `options(unitizer.state='suggested')` to your 'Rprofile' file to enable, or `options(unitizer.state='off')` to quash this message without enabling.  Prior to enabling, be sure to read `?unitizerState`,in particular the 'CRAN non-compliance' section.
  
  
                                                                                  
  Preloads...
                                                                                  
  Loading unitizer data...
                                                                                  
  Parsing tests...
                                                                                  
  Parsing unitizer/abstract.R
                                                                                  
  Parsing unitizer/alike.R
                                                                                  
  Parsing unitizer/all-bw.R
                                                                                  
  Parsing unitizer/classes.R
                                                                                  
  Parsing unitizer/cstringr.R
                                                                                  
  Parsing unitizer/eval.R
                                                                                  
  Parsing unitizer/internal.R
                                                                                  
  Parsing unitizer/language.R
                                                                                  
  Parsing unitizer/misc.R
                                                                                  
  Parsing unitizer/parse.R
                                                                                  
  Parsing unitizer/tev.R
                                                                                  
  Parsing unitizer/type.R
                                                                                  
  Parsing unitizer/validate.R
                                                                                  
  Parsing unitizer/validate.args.R
                                                                                  
  
                                                                                  
   1/14 abstract.R: 
                                                                                  
   1/14 abstract.R: library(vetr)
                                                                                  
   1/14 abstract.R: abstract(1:10)
                                                                                  
   1/14 abstract.R: abstract(list(a = 1:10, b = runif(10)))
                                                                                  
   1/14 abstract.R: abstract(matrix(1:9, nrow = 3))
                                                                                  
   1/14 abstract.R: abstract(array(1:8, c(2, 2, 2), dimnames = list(letters[1:2], 
                                                                                  
   1/14 abstract.R: list.arr <- replicate(8, list(1), simplify = FALSE)
                                                                                  
   1/14 abstract.R: dim(list.arr) <- rep(2, 3)
                                                                                  
   1/14 abstract.R: abstract(list.arr)
                                                                                  
   1/14 abstract.R: abstract(list(1, NULL))
                                                                                  
   1/14 abstract.R: alike(abstract(iris), iris[1:10, ])
                                                                                  
   1/14 abstract.R: alike(abstract(iris), iris[1:10, 1:3])
                                                                                  
   1/14 abstract.R: alike(abstract(iris), transform(iris, Species = as.character(S
                                                                                  
   1/14 abstract.R: my.env <- new.env()
                                                                                  
   1/14 abstract.R: identical(my.env, abstract(my.env))
                                                                                  
   1/14 abstract.R: y <- ts(runif(12), start = 1970, frequency = 12)
                                                                                  
   1/14 abstract.R: attr(abstract(y), "tsp")
                                                                                  
   1/14 abstract.R: attr(abstract(y, "start"), "tsp")
                                                                                  
   1/14 abstract.R: attr(abstract(y, "end"), "tsp")
                                                                                  
   1/14 abstract.R: attr(abstract(y, "frequency"), "tsp")
                                                                                  
   1/14 abstract.R: attr(abstract(y, c("start", "frequency")), "tsp")
                                                                                  
   1/14 abstract.R: abstract(y, "boom")
                                                                                  
   1/14 abstract.R: vetr:::abstract.ts(1:12)
                                                                                  
   1/14 abstract.R: obj <- new("unitizerGlobalState")
                                                                                  
   1/14 abstract.R: abstract(obj)
                                                                                  
   1/14 abstract.R: nullify(obj, 1)
                                                                                  
   1/14 abstract.R: set.seed(1)
                                                                                  
   1/14 abstract.R: df1 <- data.frame(x = runif(10), y = runif(10), z = runif(10))
                                                                                  
   1/14 abstract.R: df2 <- data.frame(a = runif(5), b = runif(5), c = runif(5))
                                                                                  
   1/14 abstract.R: mdl <- lm(y ~ x + poly(z, 2), df1)
                                                                                  
   1/14 abstract.R: alike(abstract(mdl), mdl)
                                                                                  
   1/14 abstract.R: mdl2 <- lm(x ~ y + poly(z, 2), df1)
                                                                                  
   1/14 abstract.R: alike(abstract(mdl), mdl2)
                                                                                  
   1/14 abstract.R: mdl3 <- lm(a ~ b + log(c), df2)
                                                                                  
   1/14 abstract.R: alike(abstract(mdl), mdl3)
                                                                                  
   1/14 abstract.R: mdl4 <- lm(a ~ b, df2)
                                                                                  
   1/14 abstract.R: alike(abstract(mdl), mdl4)
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3), 2)
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3), -2)
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3, 4), c(TRUE, FALSE))
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3, 4), c(TRUE, FALSE, FALSE))
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3, 4), c(rep(FALSE, 4), TRUE))
                                                                                  
   1/14 abstract.R: nullify(list(a = 1, b = 2, 3, 4), c("a", "b"))
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3, 4), "hello")
                                                                                  
   1/14 abstract.R: nullify(list(1, 2, 3), 4)
                                                                                  
   1/14 abstract.R: iris.null <- nullify(iris[1:10, ], 4)
                                                                                  
   1/14 abstract.R: as.list(iris.null)
                                                                                  
   1/14 abstract.R: class(iris.null)
                                                                                  
   1/14 abstract.R: nullify(letters, 5)
                                                                                  
   1/14 abstract.R: nullify(structure(letters[1:2], class = "xqwer892jahaksdf"), 
                                                                                  
  
                                                                                  
   2/14 alike.R: 
                                                                                  
   2/14 alike.R: library(vetr)
                                                                                  
   2/14 alike.R: alike(integer(), 1:3)
                                                                                  
   2/14 alike.R: alike(integer(5L), 1:3)
                                                                                  
   2/14 alike.R: alike(integer(3L), 1:3)
                                                                                  
   2/14 alike.R: alike(numeric(), c(1, 2, 3))
                                                                                  
   2/14 alike.R: alike(numeric(), 1L)
                                                                                  
   2/14 alike.R: alike(numeric(), c(1.1, 0.053, 41.8))
                                                                                  
   2/14 alike.R: alike(integer(3L), 1:3 + 0.01)
                                                                                  
   2/14 alike.R: alike(integer(6L), seq(1/6, 1, 1/6) * 6)
                                                                                  
   2/14 alike.R: alike(integer(4L), letters[1:4])
                                                                                  
   2/14 alike.R: alike(letters[1:4], c("hello", "goodbye", "ba", "da"))
                                                                                  
   2/14 alike.R: alike(integer(), NULL)
                                                                                  
   2/14 alike.R: alike(c(a = 1, b = 2), 3)
                                                                                  
   2/14 alike.R: alike(c(a = 1, b = 2), c(1, 2))
                                                                                  
   2/14 alike.R: lst <- list(list(1, 2), list(3, list(4, list(5, list(6, 6.1, 
                                                                                  
   2/14 alike.R: lst.2 <- list(list(11, 21), list(31, list(41, list(51, list(61)))
                                                                                  
   2/14 alike.R: alike(lst, lst.2)
                                                                                  
   2/14 alike.R: lst.3 <- lst.2
                                                                                  
   2/14 alike.R: lst.3[[2]][[2]][[2]][[2]] <- matrix(1:9, nrow = 3)
                                                                                  
   2/14 alike.R: alike(lst, lst.3)
                                                                                  
   2/14 alike.R: alike(1:10, "hello")
                                                                                  
   2/14 alike.R: alike(lst, lst)
                                                                                  
   2/14 alike.R: lst.4 <- lst
                                                                                  
   2/14 alike.R: lst.4[[2]][[2]] <- list()
                                                                                  
   2/14 alike.R: alike(lst.4, lst)
                                                                                  
   2/14 alike.R: alike(lst, lst.4)
                                                                                  
   2/14 alike.R: lst.5 <- list(1, list(a = 1, b = 2, c = list(d = 1)))
                                                                                  
   2/14 alike.R: lst.6 <- list(1, list(a = 1, b = 2, c = list(d = "hello")))
                                                                                  
   2/14 alike.R: lst.5.1 <- list(1, list(a = 1, b = 2, `c d` = list(d = 1)))
                                                                                  
   2/14 alike.R: lst.6.1 <- list(1, list(a = 1, b = 2, `c d` = list(d = "hello")))
                                                                                  
   2/14 alike.R: alike(lst.5, lst.6)
                                                                                  
   2/14 alike.R: alike(lst.6, lst.5)
                                                                                  
   2/14 alike.R: alike(lst.5.1, lst.6.1)
                                                                                  
   2/14 alike.R: alike(lst.6.1, lst.5.1)
                                                                                  
   2/14 alike.R: alike(pairlist(a = 1, b = "character"), pairlist(a = 1, b = lette
                                                                                  
   2/14 alike.R: alike(pairlist(1, "character"), pairlist(1, letters))
                                                                                  
   2/14 alike.R: alike(NULL, 1:3)
                                                                                  
   2/14 alike.R: alike(list(NULL), list(1:3))
                                                                                  
   2/14 alike.R: alike(list(NULL, NULL), list(list(list(1, 2, 3)), 1:25))
                                                                                  
   2/14 alike.R: alike(list(NULL), list(1, 2))
                                                                                  
   2/14 alike.R: alike(list(), list(1, 2))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), ncol = 7), matrix(1:21, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), nrow = 3), matrix(1:21, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(character(), nrow = 3), matrix(1:21, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), nrow = 4), matrix(1:21, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), ncol = 3, dimnames = list(NULL, c("R", 
                                                                                  
   2/14 alike.R: alike(matrix(integer(), nrow = 3, dimnames = list(c("R", "G", 
                                                                                  
   2/14 alike.R: alike(matrix(integer(), nrow = 3, dimnames = list(c("R", "G", 
                                                                                  
   2/14 alike.R: alike(matrix(integer(), nrow = 3, dimnames = list(c("R", "G", 
                                                                                  
   2/14 alike.R: alike(matrix(1:9, nrow = 3), 1:9)
                                                                                  
   2/14 alike.R: mx.tpl <- matrix(integer(), ncol = 3, dimnames = list(row.id = NU
                                                                                  
   2/14 alike.R: mx.cur <- matrix(sample(0:255, 12), ncol = 3, dimnames = list(row
                                                                                  
   2/14 alike.R: mx.cur2 <- matrix(sample(0:255, 12), ncol = 3, dimnames = list(1:
                                                                                  
   2/14 alike.R: alike(mx.tpl, mx.cur)
                                                                                  
   2/14 alike.R: alike(mx.tpl, mx.cur2)
                                                                                  
   2/14 alike.R: alike(mtcars, 1:3)
                                                                                  
   2/14 alike.R: alike(1:3, mtcars)
                                                                                  
   2/14 alike.R: alike(data.frame(), data.frame(a = 1:3, b = letters[1:3]))
                                                                                  
   2/14 alike.R: alike(data.frame(a = integer(), b = factor()), data.frame(a = 1:3
                                                                                  
   2/14 alike.R: alike(data.frame(a = factor(), b = factor()), data.frame(a = 1:3,
                                                                                  
   2/14 alike.R: alike(list(NULL, structure("a", class = "x")), list(NULL, structu
                                                                                  
   2/14 alike.R: alike(list(integer(), data.frame(a = integer(), b = numeric()), 
                                                                                  
   2/14 alike.R: df.tpl <- structure(list(1:4, factor(LETTERS[1:4], levels = LETTE
                                                                                  
   2/14 alike.R: df.cur <- `row.names<-`(data.frame(id = 5:8, val = factor(LETTERS
                                                                                  
   2/14 alike.R: df.cur2 <- `row.names<-`(data.frame(id = 5:8, val = factor(LETTER
                                                                                  
   2/14 alike.R: alike(df.tpl, df.cur)
                                                                                  
   2/14 alike.R: alike(df.cur, df.tpl)
                                                                                  
   2/14 alike.R: alike(df.tpl, df.cur2)
                                                                                  
   2/14 alike.R: df.tpl <- structure(list(1:4, letters[1:4]), names = c("id", 
                                                                                  
   2/14 alike.R: df.cur <- structure(list(1:4, letters[1:4]), names = c("id", 
                                                                                  
   2/14 alike.R: alike(df.tpl, df.tpl)
                                                                                  
   2/14 alike.R: alike(df.tpl, df.cur)
                                                                                  
   2/14 alike.R: alike(mtcars, iris)
                                                                                  
   2/14 alike.R: alike(mtcars, mtcars[1:10, ])
                                                                                  
   2/14 alike.R: alike(mtcars[-5], mtcars)
                                                                                  
   2/14 alike.R: ts.1 <- ts(runif(24), 1970, frequency = 12)
                                                                                  
   2/14 alike.R: ts.2 <- ts(runif(24), 1970, frequency = 4)
                                                                                  
   2/14 alike.R: ts.3 <- abstract(ts.1, "end")
                                                                                  
   2/14 alike.R: ts.4 <- abstract(ts.2, "frequency")
                                                                                  
   2/14 alike.R: alike(ts.1, ts.2)
                                                                                  
   2/14 alike.R: alike(ts.3, ts.1)
                                                                                  
   2/14 alike.R: alike(ts.1, ts.3)
                                                                                  
   2/14 alike.R: alike(ts.3, ts.2)
                                                                                  
   2/14 alike.R: ts.5 <- ts(matrix(runif(24 * 3), ncol = 3), 1970, frequency = 12)
                                                                                  
   2/14 alike.R: ts.6 <- ts(matrix(runif(12 * 3), ncol = 3), 1970, frequency = 12)
                                                                                  
   2/14 alike.R: alike(ts.5, ts.6)
                                                                                  
   2/14 alike.R: alike(ts.5, matrix(runif(24 * 3), ncol = 3))
                                                                                  
   2/14 alike.R: f1 <- factor(letters[1:5])
                                                                                  
   2/14 alike.R: f2 <- factor(letters[1:5], levels = letters[5:1])
                                                                                  
   2/14 alike.R: f3 <- f1
                                                                                  
   2/14 alike.R: levels(f3)[[5]] <- ""
                                                                                  
   2/14 alike.R: f4 <- factor(c(letters[1:4], "f"))
                                                                                  
   2/14 alike.R: alike(f1, f2)
                                                                                  
   2/14 alike.R: alike(f1, f3)
                                                                                  
   2/14 alike.R: alike(f1, f4)
                                                                                  
   2/14 alike.R: alike(f3, f1)
                                                                                  
   2/14 alike.R: alike(f3, f4)
                                                                                  
   2/14 alike.R: env0 <- new.env()
                                                                                  
   2/14 alike.R: env1 <- list2env(list(a = character(), b = list(), c = NULL))
                                                                                  
   2/14 alike.R: env2 <- list2env(list(a = "hello", b = iris, c = matrix(1:3)))
                                                                                  
   2/14 alike.R: env3 <- list2env(list(a = "hello", b = iris))
                                                                                  
   2/14 alike.R: env4 <- list2env(list(a = "hello", b = iris, c = logical(1L), 
                                                                                  
   2/14 alike.R: env5 <- list2env(list(b = iris, a = "hello", c = matrix(1:3)))
                                                                                  
   2/14 alike.R: alike(env0, env2)
                                                                                  
   2/14 alike.R: alike(env1, env2)
                                                                                  
   2/14 alike.R: alike(env1, env3)
                                                                                  
   2/14 alike.R: alike(env3, env1)
                                                                                  
   2/14 alike.R: alike(env1, env4)
                                                                                  
   2/14 alike.R: alike(env1, env5)
                                                                                  
   2/14 alike.R: rec.env <- rec.env.cpy <- new.env()
                                                                                  
   2/14 alike.R: for (i in 1:50) {
                                                                                  
   2/14 alike.R: rec.env.cpy$a <- rec.env
                                                                                  
   2/14 alike.R: alike(rec.env, rec.env)
                                                                                  
   2/14 alike.R: plst1 <- pairlist(a = character(), b = list(), c = NULL)
                                                                                  
   2/14 alike.R: plst2 <- pairlist(a = "hello", b = iris, c = matrix(1:3))
                                                                                  
   2/14 alike.R: plst3 <- pairlist(a = "hello", b = iris)
                                                                                  
   2/14 alike.R: plst4 <- pairlist(a = "hello", b = iris, c = logical(1L), d = log
                                                                                  
   2/14 alike.R: plst5 <- pairlist(a = character(), b = list(), integer())
                                                                                  
   2/14 alike.R: plst6 <- pairlist(a = character(), b = list(), boogey = 1:3)
                                                                                  
   2/14 alike.R: plst7 <- pairlist(a = character(), boogey = 1:3, b = list())
                                                                                  
   2/14 alike.R: alike(plst1, plst2)
                                                                                  
   2/14 alike.R: alike(plst1, plst3)
                                                                                  
   2/14 alike.R: alike(plst1, plst4)
                                                                                  
   2/14 alike.R: alike(plst1, plst5)
                                                                                  
   2/14 alike.R: alike(plst5, plst6)
                                                                                  
   2/14 alike.R: alike(plst5, plst7)
                                                                                  
   2/14 alike.R: env7 <- list2env(list(a = character(), b = plst1))
                                                                                  
   2/14 alike.R: env8 <- list2env(list(a = letters[1:3], b = plst2))
                                                                                  
   2/14 alike.R: env9 <- list2env(list(a = letters[1:3], b = plst5))
                                                                                  
   2/14 alike.R: alike(env7, env8)
                                                                                  
   2/14 alike.R: alike(env7, env9)
                                                                                  
   2/14 alike.R: env.nest.1 <- env.nest.1.cpy <- new.env()
                                                                                  
   2/14 alike.R: env.nest.2 <- env.nest.2.cpy <- new.env()
                                                                                  
   2/14 alike.R: for (i in 1:26) {
                                                                                  
   2/14 alike.R: alike(env.nest.1, env.nest.2, settings = vetr_settings(env.depth.
                                                                                  
   2/14 alike.R: alike(.GlobalEnv, env.nest.1)
                                                                                  
   2/14 alike.R: alike(quote(1 + 1), quote(x + y))
                                                                                  
   2/14 alike.R: alike(quote(fun(1 + 1)), quote(fun(x + y, 9)))
                                                                                  
   2/14 alike.R: alike(quote(fun(x + y, 9)), quote(fun(1 + 1)))
                                                                                  
   2/14 alike.R: "%plusq%" <- function(x, y) call("+", substitute(x), substitute(y
                                                                                  
   2/14 alike.R: alike(quote(1 + 1), 1 %plusq% b)
                                                                                  
   2/14 alike.R: fun <- function(a, b, c) NULL
                                                                                  
   2/14 alike.R: alike(quote(fun(b = fun2(x, y), 1, 3)), quote(fun(NULL, fun2(a, 
                                                                                  
   2/14 alike.R: alike(quote(fun(b = fun2(x, y), 1, 3)), quote(fun(NULL, fun2(a, 
                                                                                  
   2/14 alike.R: alike(quote(fun(b = fun2(x, y), 1, 3)), quote(fun(fun2(a, b), 
                                                                                  
   2/14 alike.R: alike(quote(fun(a = 1)), quote(fun(b = 1)))
                                                                                  
   2/14 alike.R: alike(quote(fun(1, 2)), quote(fun(1)))
                                                                                  
   2/14 alike.R: alike(quote(fun(1)), quote(fun(1, 2)))
                                                                                  
   2/14 alike.R: alike(quote(fun(1, 2)), quote(fun2(1, 2)))
                                                                                  
   2/14 alike.R: alike(quote(fun(1, fun2(3))), quote(fun(1, fun(3))))
                                                                                  
   2/14 alike.R: alike(quote(fun()), quote(fun(a, b, c)))
                                                                                  
   2/14 alike.R: alike(quote(fun()), quote(fun2(a, b, c)))
                                                                                  
   2/14 alike.R: alike(quote(fun(a, fun2())), quote(fun(b, fun2(a, b, c))))
                                                                                  
   2/14 alike.R: c0 <- quote(fun(a, b, a, 25))
                                                                                  
   2/14 alike.R: c0.1 <- c0.2 <- c0
                                                                                  
   2/14 alike.R: attr(c0.1, "blah") <- "hello"
                                                                                  
   2/14 alike.R: attr(c0.2, "blah") <- 1:3
                                                                                  
   2/14 alike.R: alike(c0, c0.1)
                                                                                  
   2/14 alike.R: alike(c0.1, c0)
                                                                                  
   2/14 alike.R: alike(c0.1, c0.2)
                                                                                  
   2/14 alike.R: alike(x ~ y, z ~ w)
                                                                                  
   2/14 alike.R: alike(x ~ y, z ~ w + 1)
                                                                                  
   2/14 alike.R: alike(x ~ y + 2, z ~ w + 1)
                                                                                  
   2/14 alike.R: alike(x ~ y + z:y, w ~ v + u:v)
                                                                                  
   2/14 alike.R: alike(z ~ w + 1, x ~ y)
                                                                                  
   2/14 alike.R: alike(y ~ x^2 + x * z + z + w:z, q ~ l^2 + l * j + j + w:j)
                                                                                  
   2/14 alike.R: alike(y ~ x^2 + x * z + z + w:z, q ~ l^3 + l * j + j + w:j)
                                                                                  
   2/14 alike.R: exp.1 <- parse(text = "x + y; fun2(fun(1, 2, 3), z)", keep.source
                                                                                  
   2/14 alike.R: exp.2 <- parse(text = "z + 2; fun(fun2(1, 2, 3), q)", keep.source
                                                                                  
   2/14 alike.R: exp.3 <- parse(text = "z + fun(3); fun(fun2(a, b, c), 3)", keep.s
                                                                                  
   2/14 alike.R: alike(exp.1, exp.2)
                                                                                  
   2/14 alike.R: alike(exp.2, exp.3)
                                                                                  
   2/14 alike.R: alike(exp.3, exp.2)
                                                                                  
   2/14 alike.R: exp.4 <- expression(1 + 1, 2 + x)
                                                                                  
   2/14 alike.R: exp.5 <- expression(1 + 1, 5 + y)
                                                                                  
   2/14 alike.R: exp.6 <- expression(1 + 1, 2 + 2)
                                                                                  
   2/14 alike.R: alike(exp.4, exp.5)
                                                                                  
   2/14 alike.R: alike(exp.4, exp.6)
                                                                                  
   2/14 alike.R: alike(quote(x), quote(y))
                                                                                  
   2/14 alike.R: alike(NULL, quote(x))
                                                                                  
   2/14 alike.R: alike(quote((NULL)), quote(y))
                                                                                  
   2/14 alike.R: alike(quote(NULL), quote(x))
                                                                                  
   2/14 alike.R: alike(quote(x), c0)
                                                                                  
   2/14 alike.R: alike(c0, quote(x))
                                                                                  
   2/14 alike.R: alike(quote((x)), quote(y))
                                                                                  
   2/14 alike.R: alike(print, print.data.frame)
                                                                                  
   2/14 alike.R: alike(print.data.frame, print)
                                                                                  
   2/14 alike.R: alike(`&&`, function() NULL)
                                                                                  
   2/14 alike.R: fun <- fun2 <- function() NULL
                                                                                  
   2/14 alike.R: attributes(fun2) <- NULL
                                                                                  
   2/14 alike.R: alike(fun, fun2)
                                                                                  
   2/14 alike.R: alike(fun, fun2, settings = vetr_settings(attr.mode = 2L))
                                                                                  
   2/14 alike.R: alike(fun2, fun, settings = vetr_settings(attr.mode = 1L))
                                                                                  
   2/14 alike.R: alike(fun2, fun, settings = vetr_settings(attr.mode = 2L))
                                                                                  
   2/14 alike.R: alike(1L, 1, settings = vetr_settings(type.mode = 1L))
                                                                                  
   2/14 alike.R: alike(1, 1L, settings = vetr_settings(type.mode = 1L))
                                                                                  
   2/14 alike.R: alike(1, 1L, settings = vetr_settings(type.mode = 2L))
                                                                                  
   2/14 alike.R: alike(1:101, 1:101 + 0)
                                                                                  
   2/14 alike.R: alike(1:101, 1:101 + 0, settings = vetr_settings(fuzzy.int.max.le
                                                                                  
   2/14 alike.R: alike(1:101, 1:101 + 0, settings = vetr_settings(fuzzy.int.max.le
                                                                                  
   2/14 alike.R: alike(list(a = 1:10), data.frame(a = 1:10))
                                                                                  
   2/14 alike.R: alike(list(a = 1:10), data.frame(a = 1:10), settings = vetr_setti
                                                                                  
   2/14 alike.R: alike(list(a = 1:10), data.frame(a = 1:10), settings = vetr_setti
                                                                                  
   2/14 alike.R: fun <- function(a, b, c) NULL
                                                                                  
   2/14 alike.R: call.a <- quote(fun(b = fun2(x, y), 1, 3))
                                                                                  
   2/14 alike.R: call.b <- quote(fun(NULL, fun2(a, b), 1))
                                                                                  
   2/14 alike.R: alike(call.a, call.b, settings = vetr_settings(env = emptyenv()))
                                                                                  
   2/14 alike.R: alike(call.a, call.b, env = emptyenv())
                                                                                  
   2/14 alike.R: alike(call.a, call.b, env = emptyenv(), settings = vetr_settings(
                                                                                  
   2/14 alike.R: alike(call.a, call.b)
                                                                                  
   2/14 alike.R: alike(`&&`, function() NULL, settings = vetr_settings(type.mode =
                                                                                  
   2/14 alike.R: alike(1, 2, settings = letters)
                                                                                  
   2/14 alike.R: alike(1, 2, settings = list())
                                                                                  
   2/14 alike.R: alike(1, 2, settings = setNames(vector("list", 16), letters[1:16]
                                                                                  
   2/14 alike.R: alike(1, 2, settings = vector("list", 16))
                                                                                  
   2/14 alike.R: alike(1L, 1)
                                                                                  
   2/14 alike.R: alike(1L, 1.1)
                                                                                  
   2/14 alike.R: alike(1.1, 1L)
                                                                                  
   2/14 alike.R: alike(1:100, 1:100 + 0)
                                                                                  
   2/14 alike.R: alike(1:101, 1:101 + 0)
                                                                                  
   2/14 alike.R: alike(integer(1L), 1)
                                                                                  
   2/14 alike.R: alike(logical(1L), TRUE)
                                                                                  
   2/14 alike.R: alike(integer(1L), 1:3)
                                                                                  
   2/14 alike.R: alike(logical(1L), c(TRUE, TRUE))
                                                                                  
   2/14 alike.R: alike(integer(), 1:10)
                                                                                  
   2/14 alike.R: alike(1:10, integer())
                                                                                  
   2/14 alike.R: alike(list(integer(), list(character(), logical(1L))), list(1:10,
                                                                                  
   2/14 alike.R: alike(list(integer(), list(character(), logical(1L))), list(1:10,
                                                                                  
   2/14 alike.R: alike(list(NULL, NULL), list(iris, mtcars))
                                                                                  
   2/14 alike.R: alike(NULL, mtcars)
                                                                                  
   2/14 alike.R: iris.fake <- transform(iris, Species = as.character(Species))
                                                                                  
   2/14 alike.R: alike(iris, iris.fake)
                                                                                  
   2/14 alike.R: iris.fake2 <- transform(iris, Species = factor(Species, levels = 
                                                                                  
   2/14 alike.R: alike(iris, iris.fake2)
                                                                                  
   2/14 alike.R: iris.tpl <- abstract(iris)
                                                                                  
   2/14 alike.R: str(iris.tpl)
                                                                                  
   2/14 alike.R: alike(iris.tpl, iris)
                                                                                  
   2/14 alike.R: alike(iris.tpl, iris[sample(1:nrow(iris), 10), ])
                                                                                  
   2/14 alike.R: alike(iris.tpl, iris[c(2, 1, 3, 4, 5)])
                                                                                  
   2/14 alike.R: alike(matrix(integer(), 3, 3), matrix(1:9, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), 3, 3), matrix(runif(9), nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), 3), matrix(1:12, nrow = 3))
                                                                                  
   2/14 alike.R: alike(matrix(integer(), 3), matrix(1:12, nrow = 4))
                                                                                  
   2/14 alike.R: alike(matrix(logical()), array(rep(TRUE, 8), rep(2, 3)))
                                                                                  
   2/14 alike.R: obj.tpl <- structure(TRUE, class = letters[1:3])
                                                                                  
   2/14 alike.R: obj.cur.1 <- structure(TRUE, class = c("x", letters[1:3]))
                                                                                  
   2/14 alike.R: obj.cur.2 <- structure(TRUE, class = c(letters[1:3], "x"))
                                                                                  
   2/14 alike.R: alike(obj.tpl, obj.cur.1)
                                                                                  
   2/14 alike.R: alike(obj.tpl, obj.cur.2)
                                                                                  
   2/14 alike.R: alike(quote(x + y), quote(a + b))
                                                                                  
   2/14 alike.R: alike(quote(x + y), quote(a - b))
                                                                                  
   2/14 alike.R: alike(quote(x + y), quote(a + a))
                                                                                  
   2/14 alike.R: alike(as.raw(integer(3)), as.raw(integer(3)))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(type.mode = 3))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(attr.mode = letters))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(lang.mode = letters))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(fuzzy.int.max.len = NA
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(suppress.warnings = NA
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(env = letters))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(width = letters))
                                                                                  
   2/14 alike.R: alike(NULL, NULL, settings = vetr_settings(env.depth.max = -1L))
                                                                                  
   2/14 alike.R: obj.tpl <- structure(integer(), a = integer())
                                                                                  
   2/14 alike.R: obj.obj <- structure(1:10, a = 1:3)
                                                                                  
   2/14 alike.R: alike(obj.tpl, obj.obj)
                                                                                  
   2/14 alike.R: obj.tpl.a <- structure(integer(), class = "foo")
                                                                                  
   2/14 alike.R: obj.obj.a <- structure(matrix(1:3))
                                                                                  
   2/14 alike.R: alike(obj.tpl.a, obj.obj.a)
                                                                                  
   2/14 alike.R: obj.tpl.b <- structure(matrix(integer()), class = "foo")
                                                                                  
   2/14 alike.R: obj.obj.b <- structure(matrix(1:3))
                                                                                  
   2/14 alike.R: alike(obj.tpl.b, obj.obj.b)
                                                                                  
   2/14 alike.R: obj.tpl.c <- structure(matrix(integer()), class = "foo")
                                                                                  
   2/14 alike.R: obj.obj.c <- structure(matrix(1:3), class = "foo")
                                                                                  
   2/14 alike.R: alike(obj.tpl.c, obj.obj.c)
                                                                                  
   2/14 alike.R: obj.tpl.d <- structure(integer(), class = "foo")
                                                                                  
   2/14 alike.R: obj.obj.d <- structure(matrix(1:3), class = "foo")
                                                                                  
   2/14 alike.R: alike(obj.tpl.d, obj.obj.d)
                                                                                  
   2/14 alike.R: obj.tpl.e <- structure(integer())
                                                                                  
   2/14 alike.R: obj.obj.e <- structure(matrix(1:3), class = "foo")
                                                                                  
   2/14 alike.R: alike(obj.tpl.e, obj.obj.e)
                                                                                  
   2/14 alike.R: obj.tpl.f <- structure(integer(), a = integer())
                                                                                  
   2/14 alike.R: obj.obj.f <- structure(matrix(1:3), z = integer(), class = "foo")
                                                                                  
   2/14 alike.R: alike(obj.tpl.f, obj.obj.f)
                                                                                  
   2/14 alike.R: obj.tpl.g <- structure(integer(), a = integer())
                                                                                  
   2/14 alike.R: obj.obj.g <- structure(matrix(1:3), z = integer(), class = "foo")
                                                                                  
   2/14 alike.R: alike(obj.tpl.g, obj.obj.g)
                                                                                  
   2/14 alike.R: obj.tpl.h <- structure(matrix(integer()))
                                                                                  
   2/14 alike.R: obj.obj.h <- structure(1:3, a = integer())
                                                                                  
   2/14 alike.R: alike(obj.tpl.h, obj.obj.h)
                                                                                  
   2/14 alike.R: alike(obj.tpl.h, obj.obj.h, settings = vetr_settings(attr.mode = 
                                                                                  
   2/14 alike.R: obj.tpl.i <- structure(character(), a = integer(), class = "boo")
                                                                                  
   2/14 alike.R: obj.obj.i <- structure(matrix(1:3))
                                                                                  
   2/14 alike.R: alike(obj.tpl.i, obj.obj.i)
                                                                                  
   2/14 alike.R: obj.tpl.k <- integer()
                                                                                  
   2/14 alike.R: obj.obj.k <- matrix(1:3)
                                                                                  
   2/14 alike.R: alike(obj.tpl.k, obj.obj.k)
                                                                                  
   2/14 alike.R: alike(obj.tpl.k, obj.obj.k, settings = vetr_settings(attr.mode = 
                                                                                  
  
                                                                                  
   3/14 all-bw.R: 
                                                                                  
   3/14 all-bw.R: library(vetr)
                                                                                  
   3/14 all-bw.R: set.seed(42)
                                                                                  
   3/14 all-bw.R: x <- runif(100)
                                                                                  
   3/14 all-bw.R: x[1] <- 1
                                                                                  
   3/14 all-bw.R: x[2] <- 0
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 1)
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 1, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 1, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 1, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 1 + 1e-06, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(x, 0 - 1e-06, 1, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(x, 0 - 1e-06, 1 + 1e-06, bounds = "()")
                                                                                  
   3/14 all-bw.R: y <- z <- x
                                                                                  
   3/14 all-bw.R: y[50] <- NA
                                                                                  
   3/14 all-bw.R: z[50] <- NaN
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1)
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(y, 0.5, 0.75, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(y, -1, 2, na.rm = TRUE, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1, na.rm = TRUE, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(y, 0 - 1e-06, 1, na.rm = TRUE, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1, na.rm = TRUE, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1 + 1e-06, na.rm = TRUE, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(y, 0, 1, na.rm = TRUE, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z, 0, 1)
                                                                                  
   3/14 all-bw.R: all_bw(z, 0, 1, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(z)
                                                                                  
   3/14 all-bw.R: all_bw(z, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: w <- runif(1000, -1000, 1000)
                                                                                  
   3/14 all-bw.R: all_bw(w, -1000, 1000)
                                                                                  
   3/14 all-bw.R: all_bw(w, -1500, 500)
                                                                                  
   3/14 all-bw.R: all_bw(w, -500, 1500)
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, 0)
                                                                                  
   3/14 all-bw.R: all_bw(0, 0, 0)
                                                                                  
   3/14 all-bw.R: all_bw(0, 0, 0, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(NA_real_)
                                                                                  
   3/14 all-bw.R: all_bw(NA_real_, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(numeric(), 0, 1)
                                                                                  
   3/14 all-bw.R: all_bw(numeric(), 0, 0, bounds = "()")
                                                                                  
   3/14 all-bw.R: n1e100 <- 1e+100
                                                                                  
   3/14 all-bw.R: n_1e100 <- -1e+100
                                                                                  
   3/14 all-bw.R: n2e100 <- 2e+100
                                                                                  
   3/14 all-bw.R: n_2e100 <- -2e+100
                                                                                  
   3/14 all-bw.R: n11e100 <- 1.1e+100
                                                                                  
   3/14 all-bw.R: n_11e100 <- -1.1e+100
                                                                                  
   3/14 all-bw.R: n1e200 <- 1e+200
                                                                                  
   3/14 all-bw.R: n_1e200 <- -1e+200
                                                                                  
   3/14 all-bw.R: z <- runif(100, n_1e100, n1e100)
                                                                                  
   3/14 all-bw.R: z[1] <- n_1e100
                                                                                  
   3/14 all-bw.R: z[2] <- n1e100
                                                                                  
   3/14 all-bw.R: r <- w <- v <- u <- x <- z
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n1e100)
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n1e100, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n1e100, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n1e100, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(c(z, n2e100), -Inf, n1e100, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n11e100, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, n11e100, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z, n_1e100, Inf)
                                                                                  
   3/14 all-bw.R: all_bw(z, n_1e100, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z, n_1e100, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z, n_1e100, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(c(z, n_2e100), n_1e100, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z, n_11e100, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z, n_11e100, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: r[50] <- NA_real_
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n11e100, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n11e100, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(r, n_11e100, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(r, n_11e100, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n1e100, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n11e100, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, -Inf, n11e100, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_1e100, Inf, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_11e100, Inf, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r, n_11e100, Inf, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(c(r, n2e100), -Inf, n1e100, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(c(r, n_2e100), n_1e100, Inf, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(z, -Inf, Inf)
                                                                                  
   3/14 all-bw.R: u[50] <- -Inf
                                                                                  
   3/14 all-bw.R: all_bw(u, n_1e200, n1e200)
                                                                                  
   3/14 all-bw.R: v[50] <- Inf
                                                                                  
   3/14 all-bw.R: all_bw(v, n_1e200, n1e200)
                                                                                  
   3/14 all-bw.R: w[50] <- -Inf
                                                                                  
   3/14 all-bw.R: w[51] <- Inf
                                                                                  
   3/14 all-bw.R: all_bw(w, -Inf, Inf)
                                                                                  
   3/14 all-bw.R: all_bw(w, -Inf, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(w, -Inf, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: x.int <- sample(-50:50)
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50, 50)
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50L, 50L)
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50, 50, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50, 50, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50, 50, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50, 50 + 1e-06, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50 - 1e-06, 50, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, -50 - 1e-06, 50 + 1e-06, bounds = "()")
                                                                                  
   3/14 all-bw.R: y.int <- z.int <- x.int
                                                                                  
   3/14 all-bw.R: y.int[50] <- NA
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50)
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -49.5, 49.5, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -51, 51, na.rm = TRUE, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50.5, 50.5, na.rm = TRUE, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50, na.rm = TRUE, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50 - 1e-06, 50, na.rm = TRUE, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50, na.rm = TRUE, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50 + 1e-06, na.rm = TRUE, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(y.int, -50, 50, na.rm = TRUE, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(x.int, 0, 0)
                                                                                  
   3/14 all-bw.R: all_bw(0L, 0, 0)
                                                                                  
   3/14 all-bw.R: all_bw(0L, 0, 0, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(NA_integer_)
                                                                                  
   3/14 all-bw.R: all_bw(NA)
                                                                                  
   3/14 all-bw.R: int.max <- (Reduce(`*`, rep(2L, 30L)) - 1L) * 2L + 1L
                                                                                  
   3/14 all-bw.R: int.min <- -int.max
                                                                                  
   3/14 all-bw.R: z.int <- x.int
                                                                                  
   3/14 all-bw.R: z.int[1] <- int.max
                                                                                  
   3/14 all-bw.R: z.int[2] <- int.min
                                                                                  
   3/14 all-bw.R: r.int <- w.int <- v.int <- u.int <- x.int <- z.int
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max)
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max - 1L, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min - 1, int.max + 1)
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min - 1, int.max + 1, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(int.max - 1L, -Inf, int.max, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min, Inf)
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, int.min + 1L, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: r.int[50] <- NA_integer_
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max - 10, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(z.int, -Inf, int.max - 1L, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(c(int.max - 1L, NA), -Inf, int.max, bounds = "()", na.rm 
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, -Inf, int.max, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min + 10, Inf, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(r.int, int.min, Inf, bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(x, 0, -1)
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, na.rm = 1)
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, na.rm = c(TRUE, FALSE))
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, na.rm = NA)
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = letters)
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = "[[")
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = "))")
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = "[")
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = "[.]")
                                                                                  
   3/14 all-bw.R: all_bw(x, -1, 1, bounds = NA_character_)
                                                                                  
   3/14 all-bw.R: all_bw(x, 1:3, 4)
                                                                                  
   3/14 all-bw.R: all_bw(x, 1, 4:5)
                                                                                  
   3/14 all-bw.R: all_bw(list(), 1, 2)
                                                                                  
   3/14 all-bw.R: all_bw(x, list(), 2)
                                                                                  
   3/14 all-bw.R: all_bw(x, 1, list())
                                                                                  
   3/14 all-bw.R: all_bw(x, list(1), 2)
                                                                                  
   3/14 all-bw.R: all_bw(x, 1, list(1))
                                                                                  
   3/14 all-bw.R: all_bw(x, "a", 1)
                                                                                  
   3/14 all-bw.R: all_bw(x, 1, "a")Error in nchar(capture) : invalid multibyte string, element 1
  Calls: local ... eval_with_capture -> do.call -> <Anonymous> -> get_text
  
  
  
  
  
  
  Error in nchar(x) : invalid multibyte string, element 1
  Calls: local ... paste0 -> word_wrap_split -> paste0 -> word_wrap -> strsplit
  | Unexpectedly exited before storing unitizer; if you were reviewing a unitizer 
  | changes to that unitizer were not saved.  Note that any unitizers you *
  | completed* review of should have been saved.
  
  Execution halted