Running 'run.R' [38s/41s]
Running the tests in 'tests/run.R' failed.
Complete output:
  > cat(getwd(), "\n")
  /home/hornik/tmp/R.check/r-devel-clang/Work/PKGS/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='recommended')` 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")
                                                                                  
   3/14 all-bw.R: two.let <- two.let.na <- two.let.inf <- c(letters, do.call(paste
                                                                                  
   3/14 all-bw.R: all_bw(letters, "a", "z")
                                                                                  
   3/14 all-bw.R: all_bw(letters, "z", "a")
                                                                                  
   3/14 all-bw.R: all_bw(letters, "a", "z", bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(letters, "a", "z", bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "aa", "zz")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", "zz")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", "zz", bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw("A", "a", "z", bounds = "(]")
                                                                                  
   3/14 all-bw.R: two.let.2 <- tail(head(two.let, -1), -1)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "(]")
                                                                                  
   3/14 all-bw.R: two.let.2[50] <- NA_character_
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.2, "a", "zz", bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, Inf, bounds = "[]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "a", Inf, bounds = "[]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, "\t", Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, "zz", bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, "zz", bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, "zz", bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let, -Inf, "zz", bounds = "[]")
                                                                                  
   3/14 all-bw.R: two.let.inf[1] <- Inf
                                                                                  
   3/14 all-bw.R: two.let.inf[2] <- -Inf
                                                                                  
   3/14 all-bw.R: all_bw(two.let.inf, -Inf, Inf, bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.inf, -Inf, Inf, bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.inf, -Inf, Inf, bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.inf, -Inf, Inf, bounds = "[]")
                                                                                  
   3/14 all-bw.R: two.let.na[50] <- NA_character_
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "()")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "[)")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "(]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "[]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, Inf, bounds = "[]")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "()", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", "zz", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "b", "zy", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zz", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zy", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zy")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zzz", bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zz", bounds = "[)", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, -Inf, "zz")
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", Inf, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", Inf)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "b", Inf, na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "\t", Inf, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", Inf, bounds = "(]", na.rm = TRUE)
                                                                                  
   3/14 all-bw.R: all_bw(two.let.na, "a", Inf)
                                                                                  
   3/14 all-bw.R: utf8 <- list(s4 = "ð\220\200\200", e4 = "ô¿¿¿", s3 = "à \200", 
                                                                                  
   3/14 all-bw.R: for (i in seq_along(utf8)) Encoding(utf8[[i]]) <- "UTF-8"
                                                                                  
   3/14 all-bw.R: all_bw(lorem.ru.phrases, "\t", utf8$e2)
                                                                                  
   3/14 all-bw.R: all_bw(lorem.cn.phrases, "\t", utf8$e3)
                                                                                  
  
                                                                                  
   4/14 classes.R: 
                                                                                  
   4/14 classes.R: library(vetr)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric())
                                                                                  
   4/14 classes.R: obj1 <- structure(numeric(), class = "hello")
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric(), class = c(letters[10:12], letters[
                                                                                  
   4/14 classes.R: obj1 <- structure(numeric(), class = letters[1:3])
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: alike(obj2, obj1)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric(), class = c("b", "a", "c"))
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric(), class = c("a", "b", "x", "c"))
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric(), class = c("a", "b", "c"))
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: obj2 <- structure(numeric(), class = c("x", "a", "b", "c"))
                                                                                  
   4/14 classes.R: alike(obj1, obj2)
                                                                                  
   4/14 classes.R: alike(obj1, obj2, settings = vetr_settings(attr.mode = 1))
                                                                                  
   4/14 classes.R: bn <- .BaseNamespaceEnv
                                                                                  
   4/14 classes.R: setClass("foo", representation(a = "character", b = "numeric"),
                                                                                  
   4/14 classes.R: setClass("bar", representation(d = "numeric", c = "numeric"), 
                                                                                  
   4/14 classes.R: setClass("baz", contains = "foo", list(c = "character"), where 
                                                                                  
   4/14 classes.R: x <- new("foo")
                                                                                  
   4/14 classes.R: y <- new("foo")
                                                                                  
   4/14 classes.R: z <- new("bar")
                                                                                  
   4/14 classes.R: v <- new("baz")
                                                                                  
   4/14 classes.R: w <- structure(list(a = character(), b = numeric()), class = "f
                                                                                  
   4/14 classes.R: alike(x, y)
                                                                                  
   4/14 classes.R: alike(x, z)
                                                                                  
   4/14 classes.R: alike(x, w)
                                                                                  
   4/14 classes.R: alike(w, x)
                                                                                  
   4/14 classes.R: alike(x, v)
                                                                                  
   4/14 classes.R: alike(v, x)
                                                                                  
   4/14 classes.R: lst.2 <- list(list(11, 21), list(31, list(41, list(51, list(61)
                                                                                  
   4/14 classes.R: lst.5 <- lst.6 <- lst.2
                                                                                  
   4/14 classes.R: lst.5[[2]][[2]][[1]] <- x
                                                                                  
   4/14 classes.R: lst.6[[2]][[2]][[1]] <- v
                                                                                  
   4/14 classes.R: alike(lst.5, lst.6)
                                                                                  
   4/14 classes.R: alike(lst.6, lst.5)
                                                                                  
   4/14 classes.R: v2 <- v
                                                                                  
   4/14 classes.R: class(v2) <- c("baz", "foo")
                                                                                  
   4/14 classes.R: alike(x, v2)
                                                                                  
   4/14 classes.R: inherits <- function(x, y) stop("pwned!!!")
                                                                                  
   4/14 classes.R: alike(y, v)
                                                                                  
   4/14 classes.R: Foo <- setRefClass("Foo", where = bn)
                                                                                  
   4/14 classes.R: Bar <- setRefClass("Bar", where = bn)
                                                                                  
   4/14 classes.R: Foo.1 <- Foo$new()
                                                                                  
   4/14 classes.R: Foo.2 <- Foo$new()
                                                                                  
   4/14 classes.R: Bar.1 <- Bar$new()
                                                                                  
   4/14 classes.R: alike(Foo.1, Foo.2)
                                                                                  
   4/14 classes.R: alike(Foo.1, Bar.1)
                                                                                  
   4/14 classes.R: var.1 <- list(1, 2, 3)
                                                                                  
   4/14 classes.R: var.2 <- list("hello", list(1, 2, 3), 5)
                                                                                  
   4/14 classes.R: class(var.1) <- "marbles"
                                                                                  
   4/14 classes.R: class(var.2) <- "marbles"
                                                                                  
   4/14 classes.R: alike(var.1, var.2)
                                                                                  
  
                                                                                  
   5/14 cstringr.R: 
                                                                                  
   5/14 cstringr.R: library(vetr)
                                                                                  
   5/14 cstringr.R: vetr:::len_chr_len(1000L)
                                                                                  
   5/14 cstringr.R: vetr:::len_chr_len(1L)
                                                                                  
   5/14 cstringr.R: vetr:::len_chr_len(1234567890L)
                                                                                  
   5/14 cstringr.R: len0 <- 1.23456789e+24
                                                                                  
   5/14 cstringr.R: vetr:::len_chr_len(len0)
                                                                                  
   5/14 cstringr.R: vetr:::len_as_chr(1000L)
                                                                                  
   5/14 cstringr.R: vetr:::len_as_chr(1L)
                                                                                  
   5/14 cstringr.R: vetr:::len_as_chr(1234567890L)
                                                                                  
   5/14 cstringr.R: vetr:::len_as_chr(len0)
                                                                                  
   5/14 cstringr.R: identical(vetr:::strmlen(lorem), nchar(lorem))
                                                                                  
   5/14 cstringr.R: vetr:::strmlen(lorem, 100L)
                                                                                  
   5/14 cstringr.R: identical(vetr:::strmcpy(lorem), lorem)
                                                                                  
   5/14 cstringr.R: vetr:::strmcpy("")
                                                                                  
   5/14 cstringr.R: vetr:::strmcpy(lorem, 20L)
                                                                                  
   5/14 cstringr.R: identical(nchar(vetr:::strmcpy(lorem, 20L)), 20L)
                                                                                  
   5/14 cstringr.R: vetr:::smprintf2("%s %s", lorem, lorem, 10L)
                                                                                  
   5/14 cstringr.R: vetr:::smprintf2("%s %s hello world there", lorem, lorem, 10L)
                                                                                  
   5/14 cstringr.R: lorem
                                                                                  
   5/14 cstringr.R: vetr:::ucfirst("hello WORLD")
                                                                                  
   5/14 cstringr.R: vetr:::lcfirst("HELLO world")
                                                                                  
   5/14 cstringr.R: vetr:::strbullet(c("hello world\nhow are things today", "once 
                                                                                  
   5/14 cstringr.R: vetr:::strbullet("hello\nblah\n", bullet = "  - ", ctd = "    
                                                                                  
   5/14 cstringr.R: vetr:::strbullet(1:10)
                                                                                  
   5/14 cstringr.R: vetr:::collapse(letters[1:5])
                                                                                  
   5/14 cstringr.R: vetr:::collapse(letters[1:5], sep = "\n")
                                                                                  
   5/14 cstringr.R: vetr:::collapse(character())
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(100)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(100.01)
                                                                                  
   5/14 cstringr.R: num0 <- 1e+09 + 0.1
                                                                                  
   5/14 cstringr.R: num1 <- -1e+09 - 0.1
                                                                                  
   5/14 cstringr.R: sub("e[+-]?\\K0*", "", vetr:::num_as_chr(num0), perl = TRUE)
                                                                                  
   5/14 cstringr.R: sub("e[+-]?\\K0*", "", vetr:::num_as_chr(num1), perl = TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(num0, as.int = TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(num1, as.int = TRUE)
                                                                                  
   5/14 cstringr.R: num2 <- 1e+09 - 0.1
                                                                                  
   5/14 cstringr.R: num3 <- -(1e+09 - 0.1)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(num2)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(num3)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(NA)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(NaN)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(Inf)
                                                                                  
   5/14 cstringr.R: vetr:::num_as_chr(-Inf)
                                                                                  
   5/14 cstringr.R: vetr:::smprintf6("%s %s %s %s %s %s", "a", "bb", "ccc", "dddd"
                                                                                  
   5/14 cstringr.R: vetr:::smprintf6("%s %s %s %s %s %s", "a", "bb", "ccc", "dddd"
                                                                                  
   5/14 cstringr.R: vetr:::smprintf6("%s %s %s %s %s %s", "a", "bb", "ccc", "dddd"
                                                                                  
   5/14 cstringr.R: vetr:::smprintf6("%s %s %s %s", "a", "bb", "ccc", "dddd", "eee
                                                                                  
   5/14 cstringr.R: vetr:::strbullet(c("hello world"), maxlen = 5L)
                                                                                  
   5/14 cstringr.R: vetr:::strbullet(c("hello world"), maxlen = 12L)
                                                                                  
   5/14 cstringr.R: vetr:::strbullet(c("hello world"), maxlen = 14L)
                                                                                  
   5/14 cstringr.R: vetr:::test_strmcpy()
                                                                                  
   5/14 cstringr.R: vetr:::test_strappend()
                                                                                  
   5/14 cstringr.R: vetr:::test_add_szt()
                                                                                  
   5/14 cstringr.R: vetr:::strmlen(list(), 100L)
                                                                                  
   5/14 cstringr.R: vetr:::test_smprintfx()
                                                                                  
   5/14 cstringr.R: vetr:::test_strappend2()
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 25L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 25L, FALSE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.tr.phrases, 25L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.tr.phrases, 25L, FALSE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.ru.phrases, 25L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.ru.phrases, 25L, FALSE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.cn.phrases, 25L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.cn.phrases, 25L, FALSE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 1:2, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 25L, 1:2)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(1:2, 25L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 2L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lorem.phrases, 3L, TRUE)
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(1:10)
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(c("a", "ab", "abc"))
                                                                                  
   5/14 cstringr.R: vetr:::char_offsets(1:10)
                                                                                  
   5/14 cstringr.R: vetr:::char_offsets(c("a", "ab", "abc"))
                                                                                  
   5/14 cstringr.R: utf8.kuhn <- readLines("unitizer/helper/UTF-8-test.txt", encod
                                                                                  
   5/14 cstringr.R: test.start <- grep("^Here come the tests:", utf8.kuhn)
                                                                                  
   5/14 cstringr.R: test.start
                                                                                  
   5/14 cstringr.R: utf8.test <- tail(utf8.kuhn, -test.start)
                                                                                  
   5/14 cstringr.R: nchar.base <- nchar(utf8.test, allowNA = TRUE)
                                                                                  
   5/14 cstringr.R: untranslatable <- is.na(nchar.base)
                                                                                  
   5/14 cstringr.R: nchar.vetr <- vetr:::nchar_u(utf8.test)
                                                                                  
   5/14 cstringr.R: base.vetr.diff <- !is.na(nchar.base) & nchar.vetr != nchar.bas
                                                                                  
   5/14 cstringr.R: unicode.10 <- c("ÂAA", "añ\200\200", "añ\200\200á\200", "añ\20
                                                                                  
   5/14 cstringr.R: Encoding(unicode.10) <- "UTF-8"
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(unicode.10[1])
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(unicode.10[2])
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(unicode.10[3])
                                                                                  
   5/14 cstringr.R: vetr:::nchar_u(unicode.10[4])
                                                                                  
   5/14 cstringr.R: vetr:::char_offsets(unicode.10[4])
                                                                                  
   5/14 cstringr.R: crit.1 <- c(n.0 = "\177", y.1 = "\200")
                                                                                  
   5/14 cstringr.R: crit.2 <- c(n.0 = "Á\221", n.1 = "Ây", y.2 = "Â\200", y.3 = "ß
                                                                                  
   5/14 cstringr.R: crit.3 <- c(n.00 = "à\237\221", n.01 = "à y", y.02 = "à \200",
                                                                                  
   5/14 cstringr.R: crit.4 <- c(n.00 = "ð\211\200\200", n.01 = "ð\220y\200", n.02 
                                                                                  
   5/14 cstringr.R: Encoding(crit.1) <- "UTF-8"
                                                                                  
   5/14 cstringr.R: Encoding(crit.2) <- "UTF-8"
                                                                                  
   5/14 cstringr.R: Encoding(crit.3) <- "UTF-8"
                                                                                  
   5/14 cstringr.R: Encoding(crit.4) <- "UTF-8"
                                                                                  
   5/14 cstringr.R: Map(vetr:::char_offsets, crit.1)
                                                                                  
   5/14 cstringr.R: Map(vetr:::char_offsets, crit.2)
                                                                                  
   5/14 cstringr.R: Map(vetr:::char_offsets, crit.3)
                                                                                  
   5/14 cstringr.R: Map(vetr:::char_offsets, crit.4)
                                                                                  
   5/14 cstringr.R: lat.1.1 <- lat.1.2 <- c("niña", "hello", "µ ¶ ¿ É ô")
                                                                                  
   5/14 cstringr.R: Encoding(lat.1.1) <- "latin1"
                                                                                  
   5/14 cstringr.R: Encoding(lat.1.2) <- "bytes"
                                                                                  
   5/14 cstringr.R: lapply(lat.1.1, vetr:::char_offsets)
                                                                                  
   5/14 cstringr.R: lapply(lat.1.2, vetr:::char_offsets)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lat.1.1, 3L, mark = FALSE)
                                                                                  
   5/14 cstringr.R: vetr:::strsub(lat.1.2, 3L, mark = FALSE)
                                                                                  
  
                                                                                  
   6/14 eval.R: 
                                                                                  
   6/14 eval.R: library(vetr)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L)), quote(xyz), 1:2)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L)), quote(xyz), c(TRUE, FALSE))
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L)), quote(xyz), c(TRUE, FALSE, 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) || NULL), quote(xyz), 1:2)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) || NULL), quote(xyz), NULL)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) || NULL), quote(xyz), c(TRUE, 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(integer(), nrow = 3) || NULL), 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(integer(), nrow = 3) || NULL), 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(integer(), nrow = 3) || vector("lis
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(integer(), nrow = 3) || vector("lis
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(integer(), nrow = 3) || list(charac
                                                                                  
   6/14 eval.R: xyz <- c(TRUE, TRUE)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) && .(all(xyz))), quote(xyz), 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) && .(all(.))), quote(xyz), 
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) && .(!any(is.na(.)))), quote(x
                                                                                  
   6/14 eval.R: xyz <- c(TRUE, NA)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) && .(!any(is.na(.)))), quote(x
                                                                                  
   6/14 eval.R: xyz <- c(TRUE, FALSE, TRUE)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(logical(2L) && .(!any(is.na(.)))), quote(x
                                                                                  
   6/14 eval.R: abc1 <- letters[1:5]
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(character(5L) && .(all(. %in% letters[1:3]
                                                                                  
   6/14 eval.R: abc2 <- rep("a", 5)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(character(5L) && .(all(. %in% letters[1:3]
                                                                                  
   6/14 eval.R: mat1 <- matrix(1:30, ncol = 3)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote((matrix(numeric(), ncol = 3) || matrix(int
                                                                                  
   6/14 eval.R: mat2 <- matrix(1:120, ncol = 3)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote((matrix(numeric(), ncol = 3) || matrix(int
                                                                                  
   6/14 eval.R: mat3 <- LETTERS[1:9]
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote((matrix(numeric(), ncol = 3) || matrix(int
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(matrix(numeric(), ncol = 3) || matrix(inte
                                                                                  
   6/14 eval.R: x <- -1:1
                                                                                  
   6/14 eval.R: y <- 1
                                                                                  
   6/14 eval.R: z <- -1
                                                                                  
   6/14 eval.R: w <- NA_integer_
                                                                                  
   6/14 eval.R: u <- integer()
                                                                                  
   6/14 eval.R: t <- 1:3
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(x), x)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(y), y)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(z), z)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(t), t)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(w), w)
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(. > 0), quote(u), u)
                                                                                  
   6/14 eval.R: vetr:::eval_check(1:3, 1:3, TRUE, env = list(1:3))
                                                                                  
   6/14 eval.R: vetr:::eval_check(quote(y), quote(x), TRUE, env = list(1:3))
                                                                                  
  
                                                                                  
   7/14 internal.R: 
                                                                                  
   7/14 internal.R: library(vetr)
                                                                                  
   7/14 internal.R: vetr:::name_compare(c("", "hello"), c("abc", "hello"))
                                                                                  
   7/14 internal.R: vetr:::name_compare(c("ab", "hello"), c("abc", "hello"))
                                                                                  
   7/14 internal.R: vetr:::name_compare(c(NA_character_, "hello"), c("abc", "hello
                                                                                  
   7/14 internal.R: vetr:::name_compare(c("ab", "hello"), c(NA_character_, "hello"
                                                                                  
   7/14 internal.R: vetr:::name_compare(c(NA_character_, "hello"), c(NA_character_
                                                                                  
   7/14 internal.R: vetr:::name_compare(1:3, 3:1)
                                                                                  
   7/14 internal.R: class1 <- letters[1:5]
                                                                                  
   7/14 internal.R: class2 <- letters[3:5]
                                                                                  
   7/14 internal.R: class3 <- letters[c(4, 3, 5)]
                                                                                  
   7/14 internal.R: class4 <- character()
                                                                                  
   7/14 internal.R: class5 <- NULL
                                                                                  
   7/14 internal.R: class6 <- list("a", "b", "c")
                                                                                  
   7/14 internal.R: vetr:::class_compare(class2, class1, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class1, class2, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class1, class1[1:3], 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class3, class2, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class3, class1, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class5, class2, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class2, class5, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class5, class5, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class6, class2, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class2, class6, 0)
                                                                                  
   7/14 internal.R: class7 <- c("a", "data.frame")
                                                                                  
   7/14 internal.R: vetr:::class_compare(class7, class1, 0)
                                                                                  
   7/14 internal.R: vetr:::class_compare(class1, class7, 0)
                                                                                  
   7/14 internal.R: dimn1 <- list(NULL, NULL, NULL)
                                                                                  
   7/14 internal.R: dimn2 <- list(a = letters[1:3], b = letters[4:6], c = letters[
                                                                                  
   7/14 internal.R: dimn3 <- list(letters[1:3], b = letters[4:6], c = letters[7:9]
                                                                                  
   7/14 internal.R: dimn4 <- list(letters[1:3], B = letters[4:6], C = letters[7:9]
                                                                                  
   7/14 internal.R: dimn5 <- list(a = LETTERS[1:3], b = letters[4:6], c = letters[
                                                                                  
   7/14 internal.R: dimn6 <- list(a = "", b = letters[4:6], c = letters[7:9])
                                                                                  
   7/14 internal.R: dimn7 <- list()
                                                                                  
   7/14 internal.R: dimn8 <- list(a = LETTERS[1:3], b = letters[4:6], c = letters[
                                                                                  
   7/14 internal.R: dimn9 <- list(a = 1:3, b = letters[4:6], c = letters[7:9])
                                                                                  
   7/14 internal.R: dimn10 <- list(a = list("a", "b", "c"), b = letters[4:6], c = 
                                                                                  
   7/14 internal.R: dimn11 <- NULL
                                                                                  
   7/14 internal.R: dimn12 <- matrix(letters[1:9], nrow = 3)
                                                                                  
   7/14 internal.R: dimn13 <- `attr<-`(dimn2, "bar", "yowza")
                                                                                  
   7/14 internal.R: dimn14 <- `attr<-`(dimn2, "bar", "yowz")
                                                                                  
   7/14 internal.R: dimn15 <- list(a = letters[1:3], b = letters[1:3])
                                                                                  
   7/14 internal.R: dimn16 <- list(a = letters[1:3], b = letters[1:3])
                                                                                  
   7/14 internal.R: attr(dimn15, "a") <- 1:2
                                                                                  
   7/14 internal.R: attr(dimn16, "a") <- 1:3
                                                                                  
   7/14 internal.R: dimn17 <- list(a = letters[1:3])
                                                                                  
   7/14 internal.R: dimn18 <- list(a = letters[1:2], b = letters[1:3])
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn3, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn3)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn3, dimn4)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn5)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn6, dimn5)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn5, dimn6)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn1)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn1, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn11, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn11, dimn11)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn7, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn7)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn7, dimn7)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn5, dimn8)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn8, dimn5)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn9, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn9)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn12)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn12, dimn12)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn2, dimn13)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn13, dimn2)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn13, dimn14)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn14, dimn13)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn15, dimn16)
                                                                                  
   7/14 internal.R: vetr:::dimname_compare(dimn17, dimn18)
                                                                                  
   7/14 internal.R: dim1 <- rep(2L, 2)
                                                                                  
   7/14 internal.R: dim2 <- rep(2L, 3)
                                                                                  
   7/14 internal.R: dim3 <- rep(2L, 4)
                                                                                  
   7/14 internal.R: dim4 <- c(1L, 1L)
                                                                                  
   7/14 internal.R: dim5 <- 2L
                                                                                  
   7/14 internal.R: dim6 <- c(1L, 2L, 3L)
                                                                                  
   7/14 internal.R: dim7 <- rep(0L, 2)
                                                                                  
   7/14 internal.R: dim8 <- c(0L, 0L, 2L)
                                                                                  
   7/14 internal.R: dim9 <- NULL
                                                                                  
   7/14 internal.R: dim10 <- letters[1:2]
                                                                                  
   7/14 internal.R: dim11 <- list(2L, 2L)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim2)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim2, dim3)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim4)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim2, dim6)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim7, dim1)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim7, dim4)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim7)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim7, dim2)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim8, dim2)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim8, dim6)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim6, dim9)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(9L, NULL)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim2, list())
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim2, cur_obj = list())
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim2, list(), list())
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim1, dim2, integer(), list())
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim9, dim6)
                                                                                  
   7/14 internal.R: vetr:::dim_compare(dim10, dim1)
                                                                                  
   7/14 internal.R: ts.1 <- attr(ts(runif(24), 1970, frequency = 12), "tsp")
                                                                                  
   7/14 internal.R: ts.2 <- attr(ts(runif(24), 1970, frequency = 4), "tsp")
                                                                                  
   7/14 internal.R: ts.3 <- ts.4 <- ts.1
                                                                                  
   7/14 internal.R: ts.3[[2L]] <- 0
                                                                                  
   7/14 internal.R: ts.4[[3L]] <- 0
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.1, ts.2)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.3, ts.2)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.4, ts.2)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.4, ts.1)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.1, ts.4)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.4, "hello")
                                                                                  
   7/14 internal.R: vetr:::ts_compare("hello", 1:3)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.1, 1:3)
                                                                                  
   7/14 internal.R: vetr:::ts_compare(ts.4, 1:4)
                                                                                  
   7/14 internal.R: vetr:::attr_compare(1, 1)
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3), matrix(integer(), 3,
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3), matrix(integer(), 3,
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3), matrix(integer(), 3,
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 4), matrix(integer(), 3,
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), ncol = 4), matrix(intege
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(NU
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(NU
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(le
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(LE
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(A 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character())), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character()), cl
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(unname(data.frame(integer(), cha
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), welp = list()), structur
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), welp = list(NULL)), stru
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), welp = list(), belp = 1:
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), class = letters[1:3]), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), class = letters[1:3]), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), class = letters[2:4]), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3), matrix(integer(), 3,
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3), matrix(integer(),
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(NU
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(LE
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(a 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(matrix(integer(), 3, 3, dimnames = list(A 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character())), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character()), cl
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), class = letters[2:4]), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character())), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(integer(), character()), cl
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), welp = list(NULL, 1:3), 
                                                                                  
   7/14 internal.R: vetr:::attr_compare(structure(list(), welp = list(NULL, 1:3), 
                                                                                  
   7/14 internal.R: vetr:::fun_alike(print, print.data.frame)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(print.data.frame, print)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(summary, summary.lm)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(summary.lm, summary)
                                                                                  
   7/14 internal.R: fn0 <- function(x, y) NULL
                                                                                  
   7/14 internal.R: fn1 <- function(x, y, z) NULL
                                                                                  
   7/14 internal.R: fn2 <- function(y, x) NULL
                                                                                  
   7/14 internal.R: fn3 <- function(x = 1, y = 2) NULL
                                                                                  
   7/14 internal.R: fn4 <- function(x, ...) NULL
                                                                                  
   7/14 internal.R: fn5 <- function(x) NULL
                                                                                  
   7/14 internal.R: fn6 <- function(x, y, z, ...) NULL
                                                                                  
   7/14 internal.R: fn7 <- function(x, ..., y) NULL
                                                                                  
   7/14 internal.R: fn8 <- function(x, a, ..., g, y) NULL
                                                                                  
   7/14 internal.R: fn9 <- function(x, a, ..., g, y, w) NULL
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn0, fn1)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn1, fn0)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn4, fn1)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn0, fn2)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn0, fn3)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn3, fn0)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn4, fn5)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn4, fn6)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn4, fn7)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn7, fn4)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn7, fn8)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(fn7, fn9)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(`+`, `-`)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(substitute, function(expr, env) NULL)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(function(expr, env) NULL, substitute)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(substitute, on.exit)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(on.exit, substitute)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(`[`, substitute)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(`[`, `&&`)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(identity, 10)
                                                                                  
   7/14 internal.R: vetr:::fun_alike(10, identity)
                                                                                  
   7/14 internal.R: el.1 <- replicate(5, new.env())
                                                                                  
   7/14 internal.R: el.2 <- el.1[c(1, 1, 2, 3, 4, 1, 2, 3, 5, 1)]
                                                                                  
   7/14 internal.R: vetr:::env_track(el.1, 1L)
                                                                                  
   7/14 internal.R: vetr:::env_track(el.2, 1L)
                                                                                  
   7/14 internal.R: vetr:::env_track(el.1, 1L, 3L)
                                                                                  
   7/14 internal.R: vetr:::env_track(list(1, 2, 3), 1L, 3L)
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("hello")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name(".hello")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("123")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("hello there")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("h1ello")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("_hello")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name(".1fail")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("NULL")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name("FALSE")
                                                                                  
   7/14 internal.R: vetr:::is_valid_name(letters)
                                                                                  
   7/14 internal.R: df1 <- list(a = 1:10, b = letters[1:10])
                                                                                  
   7/14 internal.R: df2 <- list(a = 1:10, b = letters[1:9])
                                                                                  
   7/14 internal.R: vetr:::is_dfish(df1)
                                                                                  
   7/14 internal.R: vetr:::is_dfish(df2)
                                                                                  
   7/14 internal.R: vetr:::is_dfish(1:10)
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(hello))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(`hello there`))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(1 + 1))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(1 %hello there% 1))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(1 + `hello there`))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(-(1:3)))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(c(-1:1, NA_integer_)))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(a == 25))
                                                                                  
   7/14 internal.R: vetr:::syntactic_names(quote(all(-1:1 > 0)))
                                                                                  
   7/14 internal.R: vetr:::pad_or_quote(quote(1 + 1))
                                                                                  
   7/14 internal.R: vetr:::pad_or_quote(quote(!anyNA(1 + 1)))
                                                                                  
   7/14 internal.R: vetr:::pad_or_quote(quote(1 + 1), syntactic = 0L)
                                                                                  
   7/14 internal.R: vetr:::pad_or_quote(quote(1 + 1), syntactic = 1L)
                                                                                  
   7/14 internal.R: vetr:::msg_sort(list(letters[5:1], letters[1:5]))
                                                                                  
   7/14 internal.R: vetr:::msg_sort(list(c("a", "a", "a", "z", "b"), c("a", "a", 
                                                                                  
   7/14 internal.R: vetr:::msg_sort(list(letters[5:1]))
                                                                                  
   7/14 internal.R: vetr:::msg_sort(as.list(letters[5:1]))
                                                                                  
   7/14 internal.R: vetr:::msg_sort(list(letters[1:5], NULL))
                                                                                  
   7/14 internal.R: vetr:::msg_sort(letters)
                                                                                  
   7/14 internal.R: msgs <- list(c("`my_var`", "be", "integer", "is", "character")
                                                                                  
   7/14 internal.R: vetr:::msg_merge(msgs)
                                                                                  
   7/14 internal.R: vetr:::msg_merge(msgs[1:3])
                                                                                  
   7/14 internal.R: vetr:::msg_merge(msgs[1])
                                                                                  
   7/14 internal.R: vetr:::msg_merge_2(msgs)
                                                                                  
   7/14 internal.R: keys <- vapply(1:26, function(x) paste0(letters[seq(x)], colla
                                                                                  
   7/14 internal.R: values <- vapply(1:26, function(x) paste0(LETTERS[seq(x)], col
                                                                                  
   7/14 internal.R: vetr:::hash_test(keys, values)
                                                                                  
   7/14 internal.R: vetr:::track_hash(letters[1:3], 2L)
                                                                                  
   7/14 internal.R: vetr:::track_hash(letters[1:5], 2L)
                                                                                  
   7/14 internal.R: vetr:::track_hash(c("a", "b", "b"), 2L)
                                                                                  
   7/14 internal.R: vetr:::track_hash(c("a", "b", NA, 1, "b"), 2L)
                                                                                  
   7/14 internal.R: vetr:::track_hash(c("a", "b", NA, 1, "a"), 2L)
                                                                                  
   7/14 internal.R: keys <- c("a", "b", NA, 1, "b", "hello", "goodbye", "a", NA, 
                                                                                  
   7/14 internal.R: vetr:::track_hash(keys, 8L)
                                                                                  
   7/14 internal.R: collisions <- c("f b", "n b", "n d", "t m", "b r", "n w", "q w
                                                                                  
   7/14 internal.R: keys.1 <- c(collisions, NA, 0, collisions)
                                                                                  
   7/14 internal.R: vetr:::track_hash(keys.1, 64L)
                                                                                  
   7/14 internal.R: keys.2 <- c(collisions, NA, 4, collisions)
                                                                                  
   7/14 internal.R: vetr:::track_hash(keys.2, 64L)
                                                                                  
   7/14 internal.R: vetr:::hash_test2(c(collisions[1:3], collisions[1:3], "hello")
                                                                                  
   7/14 internal.R: vetr:::alike_mode(NULL)
                                                                                  
   7/14 internal.R: vetr:::alike_mode(quote(a))
                                                                                  
   7/14 internal.R: vetr:::alike_mode(mean)
                                                                                  
   7/14 internal.R: vetr:::alike_mode(`+`)
                                                                                  
   7/14 internal.R: vetr:::alike_mode(log)
                                                                                  
   7/14 internal.R: vetr:::alike_mode(quote(1 + 1))
                                                                                  
   7/14 internal.R: fun <- function(x, y) NULL
                                                                                  
   7/14 internal.R: vetr:::find_fun(quote(fun), environment())
                                                                                  
   7/14 internal.R: vetr:::find_fun(quote(asdhfqwerasdfasdf), environment())
                                                                                  
   7/14 internal.R: fun2 <- function(x) vetr:::find_fun(quote(x), environment())
                                                                                  
   7/14 internal.R: fun2()
                                                                                  
  
                                                                                  
   8/14 language.R: 
                                                                                  
   8/14 language.R: library(vetr)
                                                                                  
   8/14 language.R: vetr:::match_call_alike(quote(var(y = 1:10, runif(10))), basee
                                                                                  
   8/14 language.R: env0 <- new.env()
                                                                                  
   8/14 language.R: env0$var <- function(yollo, zambia) NULL
                                                                                  
   8/14 language.R: vetr:::match_call_alike(quote(var(y = 1:10, runif(10))), env0)
                                                                                  
   8/14 language.R: c0 <- quote(fun(a, b, a, 25))
                                                                                  
   8/14 language.R: c1 <- quote(fun(x, y, x, "hello"))
                                                                                  
   8/14 language.R: c2 <- quote(fun(x, y, z, "hello"))
                                                                                  
   8/14 language.R: c3 <- quote(FUN(x, y, x, 1.01))
                                                                                  
   8/14 language.R: c4 <- quote(fun(x, y, x, z))
                                                                                  
   8/14 language.R: c5 <- quote(fun(a + b + a, FUN(z, a + 1)))
                                                                                  
   8/14 language.R: c6 <- quote(fun(x + y + x, FUN(w, x + 2)))
                                                                                  
   8/14 language.R: c7 <- quote(fun(x + y + x, FUN(w, y + 2)))
                                                                                  
   8/14 language.R: c8 <- quote(fun(x + y + x, FUN(w, x - 2)))
                                                                                  
   8/14 language.R: c9 <- quote(fun(x + y + x, FUN(w, x + "hello")))
                                                                                  
   8/14 language.R: c10 <- quote(fun(1))
                                                                                  
   8/14 language.R: c11 <- quote(fun(1, 2))
                                                                                  
   8/14 language.R: c12 <- quote(a + b + c)
                                                                                  
   8/14 language.R: c13 <- quote((a + b) + c)
                                                                                  
   8/14 language.R: c14 <- quote(a + (b + c))
                                                                                  
   8/14 language.R: vetr:::lang_alike(c0, c1, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c0, c2, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c0, c3, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c0, c4, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c5, c6, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c5, c7, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c5, c8, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c5, c9, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c11, c10, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c12, c13)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c12, c14)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c13, c14)
                                                                                  
   8/14 language.R: vetr:::lang_alike(c14, c13)
                                                                                  
   8/14 language.R: fun <- function(abc, bcd, efg) NULL
                                                                                  
   8/14 language.R: ca <- quote(fun(a, b, a))
                                                                                  
   8/14 language.R: cb <- quote(fun(x, e = x, y))
                                                                                  
   8/14 language.R: vetr:::lang_alike(ca, cb, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(cb, ca, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(ca, cb)
                                                                                  
   8/14 language.R: ca.1 <- ca
                                                                                  
   8/14 language.R: cb.1 <- cb
                                                                                  
   8/14 language.R: ca.1[[1]] <- fun
                                                                                  
   8/14 language.R: cb.1[[1]] <- fun
                                                                                  
   8/14 language.R: vetr:::lang_alike(ca.1, cb.1)
                                                                                  
   8/14 language.R: cc <- quote(fun(a, b, fun(b = 1)))
                                                                                  
   8/14 language.R: cd <- quote(fun(a, b, fun(c = 1)))
                                                                                  
   8/14 language.R: vetr:::lang_alike(cc, cd)
                                                                                  
   8/14 language.R: ce <- quote(fun(a, b, NULL))
                                                                                  
   8/14 language.R: vetr:::lang_alike(cc, ce)
                                                                                  
   8/14 language.R: vetr:::lang_alike(ce, cc)
                                                                                  
   8/14 language.R: da <- quote(ff(a = 1, b = 2, c = 3))
                                                                                  
   8/14 language.R: db <- quote(ff(a = 1, d = 2, c = 3))
                                                                                  
   8/14 language.R: vetr:::lang_alike(da, db)
                                                                                  
   8/14 language.R: vetr:::lang_alike(cc, 1:10)
                                                                                  
   8/14 language.R: vetr:::lang_alike(ce, cc, match.call.env = 1:10)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c0, c1, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c0, c2, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c0, c3, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c0, c4, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c5, c6, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c5, c7, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c5, c8, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(c5, c9, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(ca, cb, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(cb, ca, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(ca, cb)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(cc, cd)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(cc, ce)
                                                                                  
   8/14 language.R: vetr:::lang_alike_chr(ce, cc)
                                                                                  
   8/14 language.R: f0 <- y ~ x + 1
                                                                                  
   8/14 language.R: f1 <- a ~ b + 1
                                                                                  
   8/14 language.R: f2 <- a ~ b + 2
                                                                                  
   8/14 language.R: f3 <- y ~ x + log(x) + z - 1
                                                                                  
   8/14 language.R: f4 <- a ~ b + log(b) + c - 1
                                                                                  
   8/14 language.R: f5 <- a ~ b + log(c) + b - 1
                                                                                  
   8/14 language.R: f6 <- a ~ b + ln(b) + c - 1
                                                                                  
   8/14 language.R: f7 <- a ~ b + log(b) + c + 1
                                                                                  
   8/14 language.R: vetr:::lang_alike(f0, f1, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(f0, f2, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(f3, f4, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(f3, f5, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(f3, f6, NULL)
                                                                                  
   8/14 language.R: vetr:::lang_alike(f3, f7, NULL)
                                                                                  
   8/14 language.R: l0 <- quote(a + b + fun(x + funz(matrix_over[25, 32]) + transf
                                                                                  
   8/14 language.R: (dep.txt <- vetr:::dep_alike(l0))
                                                                                  
   8/14 language.R: vetr:::dep_alike(l0, 30)
                                                                                  
   8/14 language.R: vetr:::pad(dep.txt)
                                                                                  
   8/14 language.R: old.opt <- options(prompt = ">>", continue = " |")
                                                                                  
   8/14 language.R: vetr:::pad(dep.txt)
                                                                                  
   8/14 language.R: options(old.opt)
                                                                                  
   8/14 language.R: vetr:::pad(dep.txt, pad = 4)
                                                                                  
   8/14 language.R: vetr:::pad(dep.txt, pad = 4, lines = 2)
                                                                                  
   8/14 language.R: vetr:::dep_oneline(quote(1 + 1 + 3 + 944254235), 10)
                                                                                  
   8/14 language.R: vetr:::dep_oneline(quote(1 + 1 + 3), 10)
                                                                                  
   8/14 language.R: vetr:::dep_oneline(quote(1 + 1 + 3), "hello")
                                                                                  
   8/14 language.R: vetr:::dep_oneline(quote(1 + 1 + 3 - (mean(1:10) + 3)), 15, 1L
                                                                                  
  
                                                                                  
   9/14 misc.R: 
                                                                                  
   9/14 misc.R: library(vetr)
                                                                                  
   9/14 misc.R: vetr:::val_all(1:10)
                                                                                  
   9/14 misc.R: vetr:::val_all(rep(TRUE, 10))
                                                                                  
   9/14 misc.R: vetr:::val_all(c(rep(TRUE, 10), FALSE, TRUE))
                                                                                  
   9/14 misc.R: vetr:::val_all(c(rep(TRUE, 5), NA, rep(TRUE, 5)))
                                                                                  
   9/14 misc.R: vetr:::val_all(FALSE)
                                                                                  
   9/14 misc.R: vetr:::val_all(TRUE)
                                                                                  
   9/14 misc.R: vetr:::val_all(logical())
                                                                                  
   9/14 misc.R: vetr:::val_all(NA)
                                                                                  
   9/14 misc.R: vetr:::val_all(c(TRUE, TRUE, NA, TRUE))
                                                                                  
   9/14 misc.R: vetr:::hash_fun(c("f b", "n b", "n d", "t m", "b r", "n w", "q w",
                                                                                  
   9/14 misc.R: capt_wo_time <- function(x) {
                                                                                  
   9/14 misc.R: capt_wo_time(bench_mark(Sys.sleep(1.2), times = 1))
                                                                                  
   9/14 misc.R: capt_wo_time(bench_mark(Sys.sleep(0.01), times = 10))
                                                                                  
   9/14 misc.R: capt_wo_time(bench_mark(1 + 1, NULL, times = 100))
                                                                                  
   9/14 misc.R: vetr:::list_as_sorted_vec(pairlist(c = 1, a = list(), b = NULL))
                                                                                  
   9/14 misc.R: vetr:::list_as_sorted_vec(pairlist(b = 1, 2, a = 3))
                                                                                  
   9/14 misc.R: vetr:::list_as_sorted_vec(pairlist())
                                                                                  
   9/14 misc.R: vetr:::list_as_sorted_vec(pairlist(a = 1))
                                                                                  
  
                                                                                  
  10/14 parse.R: 
                                                                                  
  10/14 parse.R: library(vetr)
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(.), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(.), quote(x + yz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(.), c(1:3))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(..), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(...), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(.zzz), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(zzz.), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(zzz), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(a + b), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(. + .), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub(quote(.(zzz)), quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::name_sub("hello", quote(xyz))
                                                                                  
  10/14 parse.R: vetr:::remove_parens(quote((a)))
                                                                                  
  10/14 parse.R: vetr:::remove_parens(quote(.(a)))
                                                                                  
  10/14 parse.R: vetr:::remove_parens(quote((((a)))))
                                                                                  
  10/14 parse.R: vetr:::remove_parens(quote((.((.(a))))))
                                                                                  
  10/14 parse.R: vetr:::remove_parens(quote((a) && .(a)))
                                                                                  
  10/14 parse.R: x <- quote(.(.) && ((a)))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(x, quote(arg_to_validate))
                                                                                  
  10/14 parse.R: x
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(FALSE), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(((FALSE))), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(((FALSE && ((TRUE))))), quote(arg_to
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(.(FALSE)), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(.), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(. && a), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(.(.)), quote(arg_to_validate))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(((a && b) || .(.))), quote(arg_to_va
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(matrix(nrow = 3)), quote(arg_to_vali
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(matrix(nrow = 3) && .(.)), quote(arg
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote((a || ((b && c))) && .(a + .)), 
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote((a || ((b && .(c)))) && (a + .(.))),
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(a && (b + .(c))), quote(arg_to_valid
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(a && .), "hello")
                                                                                  
  10/14 parse.R: vetr:::symb_sub(INT.1)
                                                                                  
  10/14 parse.R: vetr:::symb_sub(NO.NA)
                                                                                  
  10/14 parse.R: x <- quote(integer(1L))
                                                                                  
  10/14 parse.R: y <- quote(integer(1L) || NULL)
                                                                                  
  10/14 parse.R: z <- quote(integer(1L) && .(!any(is.na(.))))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(x), quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(y), quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(z), quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(quote(z || NULL), quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(INT.1, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(INT, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(CHR.1, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(CHR, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(NUM.1, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(NUM, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(LGL.1, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(LGL, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(CPX.1, quote(w))
                                                                                  
  10/14 parse.R: vetr:::parse_validator(CPX, quote(w))
                                                                                  
  
                                                                                  
  11/14 tev.R: 
                                                                                  
  11/14 tev.R: library(vetr)
                                                                                  
  11/14 tev.R: tev(runif(2), numeric(2))
                                                                                  
  11/14 tev.R: tev(runif(3), numeric(2))
                                                                                  
  
                                                                                  
  12/14 type.R: 
                                                                                  
  12/14 type.R: library(vetr)
                                                                                  
  12/14 type.R: type_of(1:100)
                                                                                  
  12/14 type.R: type_of(1.1)
                                                                                  
  12/14 type.R: type_of(1:100 + 1)
                                                                                  
  12/14 type.R: type_of(1:100 + 1/1e+09)
                                                                                  
  12/14 type.R: type_of(NA_real_)
                                                                                  
  12/14 type.R: type_of(Inf)
                                                                                  
  12/14 type.R: type_of(-Inf)
                                                                                  
  12/14 type.R: type_alike(1, 1.1)
                                                                                  
  12/14 type.R: type_alike(1L, 1.1)
                                                                                  
  12/14 type.R: type_alike(1L, 1.00000001)
                                                                                  
  12/14 type.R: type_alike(1L, 1)
                                                                                  
  12/14 type.R: type_alike(1, 1.1, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(1L, 1, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(1, 1L, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(1, 1L, vetr_settings(type.mode = 2))
                                                                                  
  12/14 type.R: type_alike(1:100, 1:100 + 0)
                                                                                  
  12/14 type.R: type_alike(1:101, 1:101 + 0)
                                                                                  
  12/14 type.R: type_alike(1:101, 1:101 + 0, vetr_settings(fuzzy.int.max.len = 200
                                                                                  
  12/14 type.R: type_alike(numeric(), c(1.1, 0.053, 41.8))
                                                                                  
  12/14 type.R: type_alike(numeric(), list(1.1))
                                                                                  
  12/14 type.R: type_alike(list(), integer())
                                                                                  
  12/14 type.R: type_alike(1000000L, 1000000L + 0.1)
                                                                                  
  12/14 type.R: type_alike(1000000L, 1000000L + 0)
                                                                                  
  12/14 type.R: type_alike(data.frame(a = 1:10), list())
                                                                                  
  12/14 type.R: type_alike(NULL, NULL)
                                                                                  
  12/14 type.R: type_alike(1/0, NA)
                                                                                  
  12/14 type.R: type_alike(1, 1.1, vetr_settings(type.mode = 1:2))
                                                                                  
  12/14 type.R: type_alike(1, 1.1, vetr_settings(fuzzy.int.max.len = 1:2))
                                                                                  
  12/14 type.R: type_alike(sd, var)
                                                                                  
  12/14 type.R: type_alike(`&&`, sd)
                                                                                  
  12/14 type.R: type_alike(`&&`, sum)
                                                                                  
  12/14 type.R: type_alike(sum, sd)
                                                                                  
  12/14 type.R: type_alike(sum, c)
                                                                                  
  12/14 type.R: type_alike(`&&`, `[`)
                                                                                  
  12/14 type.R: type_alike(sd, 1:3)
                                                                                  
  12/14 type.R: type_alike(sd, var, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(`&&`, sd, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(`&&`, sum, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(sum, sd, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(sum, c, vetr_settings(type.mode = 1))
                                                                                  
  12/14 type.R: type_alike(`&&`, `[`, vetr_settings(type.mode = 1))
                                                                                  
  
                                                                                  
  13/14 validate.R: 
                                                                                  
  13/14 validate.R: library(vetr)
                                                                                  
  13/14 validate.R: set.seed(1)
                                                                                  
  13/14 validate.R: vet(INT.1, 1)
                                                                                  
  13/14 validate.R: vet(INT.1.POS, 1)
                                                                                  
  13/14 validate.R: vet(INT.1.NEG, -1)
                                                                                  
  13/14 validate.R: vet(INT.1.POS.STR, 1)
                                                                                  
  13/14 validate.R: vet(INT.1.NEG.STR, -1)
                                                                                  
  13/14 validate.R: vet(INT, -1:1)
                                                                                  
  13/14 validate.R: vet(INT.POS, 0:3)
                                                                                  
  13/14 validate.R: vet(INT.NEG, 0:-3)
                                                                                  
  13/14 validate.R: vet(INT.POS.STR, 1:3)
                                                                                  
  13/14 validate.R: vet(INT.NEG.STR, -(1:3))
                                                                                  
  13/14 validate.R: vet(NUM.1, 1.44)
                                                                                  
  13/14 validate.R: vet(NUM.1.POS, 1.44)
                                                                                  
  13/14 validate.R: vet(NUM.1.NEG, -1.44)
                                                                                  
  13/14 validate.R: vet(NUM, runif(5))
                                                                                  
  13/14 validate.R: vet(NUM.POS, runif(5))
                                                                                  
  13/14 validate.R: vet(NUM.NEG, -runif(5))
                                                                                  
  13/14 validate.R: vet(CHR, character())
                                                                                  
  13/14 validate.R: vet(CHR.1, "hello")
                                                                                  
  13/14 validate.R: vet(CHR, letters)
                                                                                  
  13/14 validate.R: vet(CPX, 1:10 + (0+0.5i))
                                                                                  
  13/14 validate.R: vet(CPX.1, 1 + (0+0.5i))
                                                                                  
  13/14 validate.R: vet(LGL, c(TRUE, FALSE))
                                                                                  
  13/14 validate.R: vet(LGL.1, TRUE)
                                                                                  
  13/14 validate.R: vet(INT.1, 1.2)
                                                                                  
  13/14 validate.R: vet(INT.1, 1:2)
                                                                                  
  13/14 validate.R: vet(INT.1, NA_integer_)
                                                                                  
  13/14 validate.R: vet(INT.1, Inf)
                                                                                  
  13/14 validate.R: vet(INT.1.POS, -1)
                                                                                  
  13/14 validate.R: vet(INT.1.POS, 1:2)
                                                                                  
  13/14 validate.R: vet(INT.1.NEG, 1)
                                                                                  
  13/14 validate.R: vet(INT.1.NEG, -(1:2))
                                                                                  
  13/14 validate.R: vet(INT.1.POS.STR, 0)
                                                                                  
  13/14 validate.R: vet(INT.1.NEG.STR, 0)
                                                                                  
  13/14 validate.R: vet(INT, c(-1:1, NA_integer_))
                                                                                  
  13/14 validate.R: vet(INT, letters)
                                                                                  
  13/14 validate.R: vet(INT.POS, -(1:3))
                                                                                  
  13/14 validate.R: vet(INT.NEG, 1:3)
                                                                                  
  13/14 validate.R: vet(INT.POS.STR, 0:3)
                                                                                  
  13/14 validate.R: vet(INT.NEG.STR, -(0:3))
                                                                                  
  13/14 validate.R: vet(NUM.1, 1.44 + 1:2)
                                                                                  
  13/14 validate.R: vet(NUM.1.POS, -runif(1) - 1)
                                                                                  
  13/14 validate.R: vet(NUM.1.NEG, runif(1) + 1)
                                                                                  
  13/14 validate.R: vet(NUM, c(NA_real_, 1))
                                                                                  
  13/14 validate.R: vet(NUM, NULL)
                                                                                  
  13/14 validate.R: vet(NUM.POS, -runif(5) - 1)
                                                                                  
  13/14 validate.R: vet(NUM.NEG, runif(5) + 1)
                                                                                  
  13/14 validate.R: vet(CHR.1, letters)
                                                                                  
  13/14 validate.R: vet(CHR, list(1, 2, 3))
                                                                                  
  13/14 validate.R: vet(CPX, list(1, 2, 3))
                                                                                  
  13/14 validate.R: vet(CPX.1, list(1, 2, 3))
                                                                                  
  13/14 validate.R: vet(LGL, NA)
                                                                                  
  13/14 validate.R: vet(LGL, letters)
                                                                                  
  13/14 validate.R: vet(LGL.1, 1:2 == 1:2)
                                                                                  
  13/14 validate.R: vet(. > 5, 1:10)
                                                                                  
  13/14 validate.R: vet(. > 5, 6:10)
                                                                                  
  13/14 validate.R: vet(.(c(TRUE, NA, TRUE)), 1:5)
                                                                                  
  13/14 validate.R: vet(.(1:5), 1:5)
                                                                                  
  13/14 validate.R: vet(.(1:5, 1:5), 1:5)
                                                                                  
  13/14 validate.R: vet(.(list(1, 2, 3)), 1:3)
                                                                                  
  13/14 validate.R: vet(.(c("hello world", "goodbye moon")), 1:3)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL, 1)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL, NULL)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL, 1.4)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || character(3L), 1)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || character(3L), 1.2)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || character(3L), letters)
                                                                                  
  13/14 validate.R: vet((matrix(integer(), 0) && nrow(.) == ncol(.)) || NULL, matr
                                                                                  
  13/14 validate.R: vet((matrix(integer(), 0) && nrow(.) == ncol(.)) || NULL, matr
                                                                                  
  13/14 validate.R: vet((matrix(integer(), 0) && nrow(.) == ncol(.)) || NULL, matr
                                                                                  
  13/14 validate.R: exp.a <- quote(all(. > 0))
                                                                                  
  13/14 validate.R: exp.b <- quote(is.vector(.))
                                                                                  
  13/14 validate.R: vet(exp.a && exp.b, -(1:3))
                                                                                  
  13/14 validate.R: local({
                                                                                  
  13/14 validate.R: vet(1 || "a" || 1 || "a" || 1 || letters, 1:3)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "text")
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "raw")
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "full")
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "halloween")
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = 1:10)
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "text", stop = TRU
                                                                                  
  13/14 validate.R: vet(INT.1 || NULL || LGL, "hello", format = "text", stop = 1:3
                                                                                  
  13/14 validate.R: vet(NO.NA, c(234234131431, 123413413413, 1341341341, 123412341
                                                                                  
  13/14 validate.R: vet(NO.NA || !anyNA(.), c(234234131431, 123413413413, 13413413
                                                                                  
  13/14 validate.R: vet(!anyNA(.), c(234234131431, 123413413413, 1341341341, 12341
                                                                                  
  13/14 validate.R: vet(!anyNA(.), c(234234131431, 123413413413, NA))
                                                                                  
  13/14 validate.R: val.exp <- quote(!anyNA(.))
                                                                                  
  13/14 validate.R: vet(val.exp, c(234234131431, 123413413413, NA))
                                                                                  
  13/14 validate.R: vet(all_bw(., 0, 1), 0:5)
                                                                                  
  13/14 validate.R: vet(all.equal(., 1:5), 1:6)
                                                                                  
  13/14 validate.R: vet(quote(quote(a + b)), quote(x2 + x3))
                                                                                  
  13/14 validate.R: x <- quote(quote(a + b))
                                                                                  
  13/14 validate.R: vet(x, quote(x2 + x3))
                                                                                  
  13/14 validate.R: vet(quote(a + b), quote(2 + x3))
                                                                                  
  13/14 validate.R: vet(quote(a + b), quote(x1 + x2 + x3))
                                                                                  
  13/14 validate.R: unlist(lapply(c("aaA", "bbB", "ccC", "ddD", "eeE"), find))
                                                                                  
  13/14 validate.R: x <- quote(aaA + bbB)
                                                                                  
  13/14 validate.R: my.env <- new.env()
                                                                                  
  13/14 validate.R: my.env$y <- quote(ccC - ddD)
                                                                                  
  13/14 validate.R: evalq(vet(quote(x * y), quote(A * (B - C))), envir = my.env)
                                                                                  
  13/14 validate.R: evalq(vet(quote(eeE * y), quote(A * (B - C))), envir = my.env)
                                                                                  
  13/14 validate.R: evalq(vet(quote(x * y), quote((A + D) * (B - C))), envir = my.
                                                                                  
  13/14 validate.R: expA <- expB <- expC <- expD <- expE <- 0
                                                                                  
  13/14 validate.R: expA <- quote(expB && expC)
                                                                                  
  13/14 validate.R: expB <- quote(expD * expE)
                                                                                  
  13/14 validate.R: expE <- quote(expA || expD)
                                                                                  
  13/14 validate.R: vet(expA, TRUE)
                                                                                  
  13/14 validate.R: expE <- quote(expA)
                                                                                  
  13/14 validate.R: vet(expA, TRUE)
                                                                                  
  13/14 validate.R: . <- quote(. > 0)
                                                                                  
  13/14 validate.R: vet(.., 1.4)
                                                                                  
  13/14 validate.R: . <- quote(numeric(1L))
                                                                                  
  13/14 validate.R: vet(.., 1.5)
                                                                                  
  13/14 validate.R: vet(1, 1, env = "hello")
                                                                                  
  13/14 validate.R: cust.tok.1 <- vet_token(quote(TRUE), "%sshould be logical(1L)"
                                                                                  
  13/14 validate.R: vet(cust.tok.1, TRUE)
                                                                                  
  13/14 validate.R: vet(cust.tok.1, 1:2)
                                                                                  
  13/14 validate.R: vet_token(quote(TRUE), "should be logical(1L)")
                                                                                  
  13/14 validate.R: vet_token(quote(TRUE), letters)
                                                                                  
  13/14 validate.R: cust.tok.2 <- quote(. > 2)
                                                                                  
  13/14 validate.R: attr(cust.tok.2, "err.msg") <- letters
                                                                                  
  13/14 validate.R: vet(cust.tok.2, TRUE)
                                                                                  
  13/14 validate.R: set1 <- vetr_settings(result.list.size.init = 1)
                                                                                  
  13/14 validate.R: vet.exp <- quote(1 || 1:2 || 1:3 || 1:4 || 1:5 || 1:6 || 1:7 |
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:8, settings = set1)
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:9, settings = set1)
                                                                                  
  13/14 validate.R: set2 <- vetr_settings(result.list.size.init = 1, result.list.s
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:8, settings = set2)
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:9, settings = set2)
                                                                                  
  13/14 validate.R: set3 <- vetr_settings(result.list.size.init = 1, result.list.s
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:8, settings = set3)
                                                                                  
  13/14 validate.R: vet(vet.exp, 1:9, settings = set3)
                                                                                  
  13/14 validate.R: set4 <- vetr_settings(result.list.size.init = "hello", result.
                                                                                  
  13/14 validate.R: set5 <- vetr_settings(result.list.size.init = 1, result.list.s
                                                                                  
  13/14 validate.R: vet(1, 1, settings = set4)
                                                                                  
  13/14 validate.R: vet(1, 1, settings = set5)
                                                                                  
  
                                                                                  
  14/14 validate.args.R: 
                                                                                  
  14/14 validate.args.R: library(vetr)
                                                                                  
  14/14 validate.args.R: fun0 <- function(x, y, z) vetr(x = matrix(integer(), ncol
                                                                                  
  14/14 validate.args.R: fun0(1, 2, 3)
                                                                                  
  14/14 validate.args.R: fun0(matrix(1), 2, 3)
                                                                                  
  14/14 validate.args.R: fun0(matrix(1:3, nrow = 1), 2, 3)
                                                                                  
  14/14 validate.args.R: fun0(matrix(1:3, nrow = 1), 2:3, 3)
                                                                                  
  14/14 validate.args.R: fun0(matrix(1:3, nrow = 1), c(2, 3), 3)
                                                                                  
  14/14 validate.args.R: fun0(matrix(1:3, nrow = 1), c(2, 3), TRUE)
                                                                                  
  14/14 validate.args.R: fun1 <- function(x, y, z) vetr(x = matrix(integer(), ncol
                                                                                  
  14/14 validate.args.R: fun1(1:3, "fail", "fail")
                                                                                  
  14/14 validate.args.R: fun1(matrix(1:9, ncol = 3), "fail", "fail")
                                                                                  
  14/14 validate.args.R: fun1(letters[1:3], "fail", "fail")
                                                                                  
  14/14 validate.args.R: fun1(1:3, 1:2, "fail")
                                                                                  
  14/14 validate.args.R: fun1(1:3, NULL, "fail")
                                                                                  
  14/14 validate.args.R: fun1(1:3, FALSE, "fail")
                                                                                  
  14/14 validate.args.R: fun1(1:3, FALSE, FALSE)
                                                                                  
  14/14 validate.args.R: fun2 <- function(x, y, z) vetr(x = (matrix(integer(), nco
                                                                                  
  14/14 validate.args.R: fun2(matrix(c(1:8, NA), nrow = 3), NULL, NULL)
                                                                                  
  14/14 validate.args.R: fun2(matrix(c(1:9), nrow = 3), -1:1, NULL)
                                                                                  
  14/14 validate.args.R: fun2(matrix(c(1:9), nrow = 3), 1:3, NA)
                                                                                  
  14/14 validate.args.R: fun2(matrix(c(1:9), nrow = 3), 1:3, TRUE)
                                                                                  
  14/14 validate.args.R: fun2a <- function(x) vetr(x = setNames(character(3L), let
                                                                                  
  14/14 validate.args.R: fun2a(letters[1:3])
                                                                                  
  14/14 validate.args.R: fun3 <- function(x, y) vetr(x = logical(1L), y = integer(
                                                                                  
  14/14 validate.args.R: fun3(stop("boom"))
                                                                                  
  14/14 validate.args.R: fun3(TRUE, stop("boomBOOM"))
                                                                                  
  14/14 validate.args.R: fun3(1:3, stop("boomBOOM"))
                                                                                  
  14/14 validate.args.R: fun4 <- function(x, y) vetr(x = stop("BOOM"), y = integer
                                                                                  
  14/14 validate.args.R: fun4(NULL, 1:3)
                                                                                  
  14/14 validate.args.R: fun5 <- function(x, y) vetr(x = integer(3L), y = NULL || 
                                                                                  
  14/14 validate.args.R: fun5(1:3, NULL)
                                                                                  
  14/14 validate.args.R: fun5(1:2, NULL)
                                                                                  
  14/14 validate.args.R: fun6 <- function(x, y) vetr(x = integer(3L), y = NULL && 
                                                                                  
  14/14 validate.args.R: fun6(1:3, NULL)
                                                                                  
  14/14 validate.args.R: fun7 <- function(x, y = z + 2) {
                                                                                  
  14/14 validate.args.R: fun7a <- function(x, y = z + 2) {
                                                                                  
  14/14 validate.args.R: z <- 1
                                                                                  
  14/14 validate.args.R: fun7(TRUE)
                                                                                  
  14/14 validate.args.R: fun7a(TRUE)
                                                                                  
  14/14 validate.args.R: fun8 <- function(x, y = z + 2) {
                                                                                  
  14/14 validate.args.R: fun8a <- function(x, y = z + 2) {
                                                                                  
  14/14 validate.args.R: a <- NULL
                                                                                  
  14/14 validate.args.R: b <- TRUE
                                                                                  
  14/14 validate.args.R: fun8(a && b)
                                                                                  
  14/14 validate.args.R: a <- TRUE
                                                                                  
  14/14 validate.args.R: fun8a(a && b)
                                                                                  
  14/14 validate.args.R: fun_make <- function() {
                                                                                  
  14/14 validate.args.R: fun <- fun_make()
                                                                                  
  14/14 validate.args.R: a <- b <- 1:9
                                                                                  
  14/14 validate.args.R: local({
                                                                                  
  14/14 validate.args.R: local({
                                                                                  
  14/14 validate.args.R: fun8b <- function(x) vetr(x = length(.) > 0 && integer())
                                                                                  
  14/14 validate.args.R: get("zfqwefkj")
                                                                                  
  14/14 validate.args.R: local({
                                                                                  
  14/14 validate.args.R: a <- quote(!anyNA(.))
                                                                                  
  14/14 validate.args.R: fun <- function(x) {
                                                                                  
  14/14 validate.args.R: fun(-(1:3))
                                                                                  
  14/14 validate.args.R: fun8 <- function(x = "hello", y = TRUE, z) vetr(x = integ
                                                                                  
  14/14 validate.args.R: fun8(1L, NULL, 1:2)
                                                                                  
  14/14 validate.args.R: fun8(1L, 1:2, NULL)
                                                                                  
  14/14 validate.args.R: fun8(1L, 1:2)
                                                                                  
  14/14 validate.args.R: fun8(1L)
                                                                                  
  14/14 validate.args.R: fun8(z = 1:2)
                                                                                  
  14/14 validate.args.R: fun1 <- function(x, y) vetr(x > 0, . < 3)
                                                                                  
  14/14 validate.args.R: fun1(1:10, 1:10)
                                                                                  
  14/14 validate.args.R: fun2 <- function(x, y) vetr(. > 0 && all(y > 0), y < 3)
                                                                                  
  14/14 validate.args.R: fun2(TRUE, 1:10)
                                                                                  
  14/14 validate.args.R: x <- 1:10
                                                                                  
  14/14 validate.args.R: vet(x > 0, x)
                                                                                  
  14/14 validate.args.R: vet((x + 1) > 0, x + 1)
                                                                                  
  14/14 validate.args.R: fun10a <- function(x, y = TRUE, z = 999) vetr(INT, LGL.1,
                                                                                  
  14/14 validate.args.R: fun10a(1, z = 1:3)
                                                                                  
  14/14 validate.args.R: fun10b <- function(x, y = TRUE, z = 999) vetr(INT, z = IN
                                                                                  
  14/14 validate.args.R: fun10b(1, z = 1:3)
                                                                                  
  
                                                                                  
  Prepping Unitizers...Warning in history_capt(history) :
    Unable to capture history in non-interactive mode.
  
                                                                                  
  | Summary of files in common directory 'unitizer':
  | 
  |                       Pass Fail
  |   1.      abstract.R    35    -
  |   2.         alike.R   198    -
  |   3.        all-bw.R   207    -
  |   4.       classes.R    22    -
  |   5.      cstringr.R    82    -
  |   6.          eval.R    30    -
  |   7.      internal.R   187    -
  |   8.      language.R    55    -
  |   9.          misc.R    17    -
  |  10.         parse.R    49    -
  |  11.           tev.R     2    -
  |  12.          type.R    41    -
  | *13.      validate.R   111    1
  |  14. validate.args.R    45    -
  | ...............................
  |                       1081    1
  | Legend:
  | * `unitizer` requires review
  
  +------------------------------------------------------------------------------+
  | unitizer for: unitizer/validate.R                                            |
  +------------------------------------------------------------------------------+
  
                           Pass Fail
              Tokens Pass    23    -
              Tokens Fail    30    -
       Custom expressions     7    -
     Compound Expressions    12    -
       Other Return Modes     7    -
         Multi-line Stuff     5    -
   Embedded String Errors     2    -
                 Language    12    -
                   Errors     1    -
            Custom tokens     4    1
            Result Buffer     8    -
  ..................................
                            111    1
  
  = Custom tokens ================================================================
  
  - Failed -----------------------------------------------------------------------
  
  | The following test failed because the new evaluation does not match the 
  | reference value from the store. Overwrite with new result ([Y]es, [N]o, 
  | [P]rev, [B]rowse, [R]erun, [Q]uit, [H]elp)?
  
  # impossible tokens
  
  > vet_token(quote(TRUE), "should be logical(1L)")
  Warning in sprintf(err.msg, "test") : argument not used by format
  Warning in sprintf(err.msg, "test") : argument not used by format
  Error in vet_token(quote(TRUE), "should be logical(1L)") : 
    Argument `err.msg` must be character(1L) and contain a single '%s' for use by 
  `sprintf`.
  Calls: local ... withCallingHandlers -> eval -> eval -> withVisible -> vet_token
  
  | Conditions mismatch: 
  
  < .REF$conditions                                                         
  > .NEW$conditions                                                         
  @@ 1,4 / 1,6 @@                                                           
  < Condition list with 1 condition:                                        
  > Condition list with 3 conditions:                                       
  < 1. Error in vet_token(quote(TRUE), "should be logical(1L)") : Argument  
  > 1. Warning in sprintf(err.msg, "test") : argument not used by format    
  > 2. Warning in sprintf(err.msg, "test") : argument not used by format    
  > 3. Error in vet_token(quote(TRUE), "should be logical(1L)") : Argument  
       `err.msg` must be character(1L) and contain a single '%s' for use by 
       `sprintf`.                                                           
  
  | State mismatch; see `.DIFF$state` for details.
  
  | User input required to proceed, but we are in non-interactive mode.
  
  | unitizer unchanged.
  
  |   * Fail: vet_token(quote(TRUE), "should be logical(1L)")
  | in 'unitizer/validate.R'
  
  | Newly evaluated tests do not match unitizer (Pass: 1081, Fail: 1); see above 
  | for more info, or run in interactive mode.
  
  Error in unitize_core(test.files = test.files, store.ids = store.ids,  : 
    Cannot proceed in non-interactive mode.
  Calls: local ... eval -> eval -> eval -> unitize_dir -> unitize_core
  Execution halted