* using log directory 'd:/Rcompile/CRANpkg/local/3.6/validatedb.Rcheck'
* using R version 3.6.3 (2020-02-29)
* using platform: x86_64-w64-mingw32 (64-bit)
* using session charset: ISO8859-1
* checking for file 'validatedb/DESCRIPTION' ... OK
* this is package 'validatedb' version '0.1.3'
* package encoding: UTF-8
* checking package namespace information ... OK
* checking package dependencies ... OK
* checking if this is a source package ... OK
* checking if there is a namespace ... OK
* checking for hidden files and directories ... OK
* checking for portable file names ... OK
* checking whether package 'validatedb' can be installed ... WARNING
Found the following significant warnings:
  Note: possible error in 'bquote(dplyr::transmute(x$query, ': unused argument (splice = TRUE) 
  Note: possible error in 'bquote(dplyr::transmute(tbl, ': unused argument (splice = TRUE) 
  Note: possible error in 'bquote({': unused argument (splice = TRUE) 
See 'd:/Rcompile/CRANpkg/local/3.6/validatedb.Rcheck/00install.out' for details.
Information on the location(s) of code generating the 'Note's can be
obtained by re-running with environment variable R_KEEP_PKG_SOURCE set
to 'yes'.
* checking installed package size ... OK
* checking package directory ... OK
* checking DESCRIPTION meta-information ... OK
* checking top-level files ... OK
* checking for left-over files ... OK
* checking index information ... OK
* checking package subdirectories ... OK
* checking R files for non-ASCII characters ... OK
* checking R files for syntax errors ... OK
* checking whether the package can be loaded ... OK
* checking whether the package can be loaded with stated dependencies ... OK
* checking whether the package can be unloaded cleanly ... OK
* checking whether the namespace can be loaded with stated dependencies ... OK
* checking whether the namespace can be unloaded cleanly ... OK
* checking loading without being on the library search path ... OK
* checking use of S3 registration ... OK
* checking dependencies in R code ... OK
* checking S3 generic/method consistency ... OK
* checking replacement functions ... OK
* checking foreign function calls ... OK
* checking R code for possible problems ... [6s] NOTE
aggregate_by_record: possible error in bquote(dplyr::transmute(x$query,
  ..(key_expr), nfails = .(fails), nNA = .(nas)), splice = TRUE):
  unused argument (splice = TRUE)
confront_tbl: possible error in bquote(dplyr::transmute(tbl,
  ..(key_expr), ..(exprs[working])), splice = TRUE): unused argument
  (splice = TRUE)
confront_tbl_sparse : <anonymous>: possible error in bquote({: unused
  argument (splice = TRUE)
confront_tbl_sparse : <anonymous>: possible error in d <-
  dplyr::transmute(tbl, ..(key_expr), rule = .(rule_name), fail =
  !.(e)): unused argument (splice = TRUE)
confront_tbl_sparse : <anonymous>: possible error in dplyr::filter(d,
  dplyr::coalesce(fail, TRUE)): unused argument (splice = TRUE)
confront_tbl_sparse : <anonymous>: possible error in }, splice = TRUE):
  unused argument (splice = TRUE)
* checking Rd files ... OK
* checking Rd metadata ... OK
* checking Rd cross-references ... OK
* checking for missing documentation entries ... OK
* checking for code/documentation mismatches ... OK
* checking Rd \usage sections ... OK
* checking Rd contents ... OK
* checking for unstated dependencies in examples ... OK
* checking examples ... ERROR
Running examples in 'validatedb-Ex.R' failed
The error most likely occurred in:

> ### Name: aggregate.tbl_validation
> ### Title: Count the number of invalid rules or records.
> ### Aliases: aggregate.tbl_validation
> 
> ### ** Examples
> 
> income <- data.frame(id = 1:2, age=c(12,35), salary = c(1000,NA))
> con <- dbplyr::src_memdb()
> tbl_income <- dplyr::copy_to(con, income, overwrite=TRUE)
> print(tbl_income)
# Source:   table<income> [?? x 3]
# Database: sqlite 3.35.5 [:memory:]
     id   age salary
  <int> <dbl>  <dbl>
1     1    12   1000
2     2    35     NA
> 
> # Let's define a rule set and confront the table with it:
> rules <- validator( is_adult   = age >= 18
+                     , has_income = salary > 0
+ )
> 
> # and confront!
> # in general with a db table it is handy to use a key
> cf <- confront(tbl_income, rules, key="id")
Error in bquote({ : unused argument (splice = TRUE)
Calls: confront ... rule_works_on_tbl -> confront_tbl_sparse -> lapply -> FUN
Execution halted
* checking for unstated dependencies in 'tests' ... OK
* checking tests ... [6s] ERROR
  Running 'testthat.R' [6s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(validatedb)
  Loading required package: validate
  
  Attaching package: 'validate'
  
  The following object is masked from 'package:testthat':
  
      compare
  
  > 
  > test_check("validatedb")
  == Failed tests ================================================================
  -- Error (test-compute.R:14:3): multiplication works ---------------------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules, key = "id") test-compute.R:14:2
   2. \-validatedb::confront(tbl_d, rules, key = "id")
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-confront.R:8:5): Confront: returns a validation object ----------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-confront.R:8:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-confront.R:19:5): Confront: handles linear constraints ----------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-confront.R:19:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-confront.R:36:5): Confront: handles categorical constraints -----
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-confront.R:36:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-confront.R:56:5): Confront: handles conditional constraints -----
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-confront.R:56:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-confront.R:73:5): Confront: warns on not working rules ----------
  Error: unused argument (splice = TRUE)
  Backtrace:
       x
    1. +-testthat::expect_warning(cf <- confront(tbl_d, rules)) test-confront.R:73:4
    2. | \-testthat:::quasi_capture(enquo(object), label, capture_warnings)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. +-validate::confront(tbl_d, rules)
    7. \-validatedb::confront(tbl_d, rules)
    8.   \-validatedb:::.local(dat, x, ref, ...)
    9.     \-validatedb::confront.tbl_sql(...)
   10.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   11.         \-validatedb:::rule_works_on_tbl(tbl, x)
   12.           \-validatedb:::confront_tbl_sparse(...)
   13.             \-base::lapply(...)
   14.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-rule_works_on_tbl.R:9:5): rule_works_on_tbl: works with numeric checks --
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. \-validatedb:::rule_works_on_tbl(tbl_d, rules) test-rule_works_on_tbl.R:9:4
   2.   \-validatedb:::confront_tbl_sparse(...)
   3.     \-base::lapply(...)
   4.       \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-rule_works_on_tbl.R:21:5): rule_works_on_tbl: fails on function not on db --
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. \-validatedb:::rule_works_on_tbl(tbl_d, rules) test-rule_works_on_tbl.R:21:4
   2.   \-validatedb:::confront_tbl_sparse(...)
   3.     \-base::lapply(...)
   4.       \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-summary.R:8:5): summary: works on a simple case -----------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-summary.R:8:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-summary.R:25:5): summary: works with failing rules --------------
  Error: unused argument (splice = TRUE)
  Backtrace:
       x
    1. +-testthat::expect_warning(cf <- confront(tbl_income, rules)) test-summary.R:25:4
    2. | \-testthat:::quasi_capture(enquo(object), label, capture_warnings)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. +-validate::confront(tbl_income, rules)
    7. \-validatedb::confront(tbl_income, rules)
    8.   \-validatedb:::.local(dat, x, ref, ...)
    9.     \-validatedb::confront.tbl_sql(...)
   10.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   11.         \-validatedb:::rule_works_on_tbl(tbl, x)
   12.           \-validatedb:::confront_tbl_sparse(...)
   13.             \-base::lapply(...)
   14.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-summary.R:39:5): summary: works on a sparse confrontation -------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules, sparse = TRUE) test-summary.R:39:4
   2. \-validatedb::confront(tbl_d, rules, sparse = TRUE)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl_sparse(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-summary.R:57:5): summary: works with failing rules (sparse) -----
  Error: unused argument (splice = TRUE)
  Backtrace:
       x
    1. +-testthat::expect_warning(cf <- confront(tbl_income, rules, sparse = TRUE)) test-summary.R:57:4
    2. | \-testthat:::quasi_capture(enquo(object), label, capture_warnings)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. +-validate::confront(tbl_income, rules, sparse = TRUE)
    7. \-validatedb::confront(tbl_income, rules, sparse = TRUE)
    8.   \-validatedb:::.local(dat, x, ref, ...)
    9.     \-validatedb::confront.tbl_sql(...)
   10.       \-validatedb:::confront_tbl_sparse(tbl = tbl, x = x, key = key)
   11.         \-validatedb:::rule_works_on_tbl(tbl, x)
   12.           \-validatedb:::confront_tbl_sparse(...)
   13.             \-base::lapply(...)
   14.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:11:5): values: returns a list of values ----------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:11:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:30:5): values: simplifies... ---------------------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:30:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:47:5): values: returns a tbl of values -----------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:47:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:65:5): values: returns a data.frame of values ----------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:65:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:81:5): values: returns a matrix... ---------------------
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:81:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:97:5): values: returns identical result as validate ----
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules) test-values.R:97:4
   2. \-validatedb::confront(tbl_d, rules)
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  -- Error (test-values.R:122:5): values: returns identical results as validate with key set --
  Error: unused argument (splice = TRUE)
  Backtrace:
      x
   1. +-validate::confront(tbl_d, rules, key = "id") test-values.R:122:4
   2. \-validatedb::confront(tbl_d, rules, key = "id")
   3.   \-validatedb:::.local(dat, x, ref, ...)
   4.     \-validatedb::confront.tbl_sql(...)
   5.       \-validatedb:::confront_tbl(tbl = tbl, x = x, key = key)
   6.         \-validatedb:::rule_works_on_tbl(tbl, x)
   7.           \-validatedb:::confront_tbl_sparse(...)
   8.             \-base::lapply(...)
   9.               \-validatedb:::FUN(X[[i]], ...)
  
  [ FAIL 19 | WARN 0 | SKIP 0 | PASS 1 ]
  Error: Test failures
  Execution halted
* checking PDF version of manual ... OK
* DONE
Status: 2 ERRORs, 1 WARNING, 1 NOTE