Running ‘testthat.R’ [5s/5s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(dplyr)
  
  Attaching package: 'dplyr'
  
  The following object is masked from 'package:testthat':
  
      matches
  
  The following objects are masked from 'package:stats':
  
      filter, lag
  
  The following objects are masked from 'package:base':
  
      intersect, setdiff, setequal, union
  
  > library(rlang)
  
  Attaching package: 'rlang'
  
  The following objects are masked from 'package:testthat':
  
      is_false, is_null, is_true
  
  > library(ruler)
  > 
  > test_check("ruler")
  ── 1. Error: expose works (@test-expose.R#162)  ────────────────────────────────
  `UQS()` can only be used within a quasiquoted argument
  1: expose_res_1 %>% expose(input_data_pack, list(list(input_col_pack)), .remove_obeyers = FALSE) at testthat/test-expose.R:162
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: expose(., input_data_pack, list(list(input_col_pack)), .remove_obeyers = FALSE)
  10: lapply(packs, expose_single, .tbl = tbl_keyed, .rule_sep = .rule_sep, .remove_obeyers = .remove_obeyers, 
         .guess = .guess) %>% impute_exposure_pack_names(.exposure_ref = present_exposure) %>% 
         add_pack_names() %>% bind_exposures()
  ...
  25: withVisible(function_list[[k]](value))
  26: function_list[[k]](value)
  27: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100))
  28: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  29: as_fun_list(.funs, .quo, .env, ...)
  30: is_fun_list(.x)
  31: rules(tot_sum = sum(.) > 100)
  32: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  33: rlang::UQS(dots)
  34: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 2. Error: expose preserves pack names (@test-expose.R#218)  ─────────────────
  `UQS()` can only be used within a quasiquoted argument
  1: input_tbl %>% expose(my_data_pack = input_data_pack, list(my_col_pack = input_col_pack), 
         list(list(my_row_pack = input_row_pack)), .remove_obeyers = TRUE) %>% get_exposure() at testthat/test-expose.R:218
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: expose(., my_data_pack = input_data_pack, list(my_col_pack = input_col_pack), list(list(my_row_pack = input_row_pack)), 
         .remove_obeyers = TRUE)
  9: lapply(packs, expose_single, .tbl = tbl_keyed, .rule_sep = .rule_sep, .remove_obeyers = .remove_obeyers, 
         .guess = .guess) %>% impute_exposure_pack_names(.exposure_ref = present_exposure) %>% 
         add_pack_names() %>% bind_exposures()
  10: eval(lhs, parent, parent)
  ...
  24: withVisible(function_list[[k]](value))
  25: function_list[[k]](value)
  26: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100))
  27: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  28: as_fun_list(.funs, .quo, .env, ...)
  29: is_fun_list(.x)
  30: rules(tot_sum = sum(.) > 100)
  31: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  32: rlang::UQS(dots)
  33: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 3. Error: expose accounts for rule separator (@test-expose.R#250)  ──────────
  `UQS()` can only be used within a quasiquoted argument
  1: input_tbl %>% expose(input_packs[["col_other"]], .rule_sep = inside_punct("_\\._"), 
         .remove_obeyers = TRUE) %>% get_exposure() at testthat/test-expose.R:250
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: expose(., input_packs[["col_other"]], .rule_sep = inside_punct("_\\._"), .remove_obeyers = TRUE)
  9: lapply(packs, expose_single, .tbl = tbl_keyed, .rule_sep = .rule_sep, .remove_obeyers = .remove_obeyers, 
         .guess = .guess) %>% impute_exposure_pack_names(.exposure_ref = present_exposure) %>% 
         add_pack_names() %>% bind_exposures()
  10: eval(lhs, parent, parent)
  ...
  24: withVisible(function_list[[k]](value))
  25: function_list[[k]](value)
  26: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100, .prefix = "_._"))
  27: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  28: as_fun_list(.funs, .quo, .env, ...)
  29: is_fun_list(.x)
  30: rules(tot_sum = sum(.) > 100, .prefix = "_._")
  31: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  32: rlang::UQS(dots)
  33: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 4. Error: expose guesses (@test-expose.R#269)  ──────────────────────────────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_expose_guesses(input_tbl, input_col_pack) at testthat/test-expose.R:269
  2: expect_identical(input_tbl %>% expose(input_rule_pack, .guess = TRUE), input_tbl %>% 
         expose(.pack)) at testthat/test-expose.R:126
  3: quasi_label(enquo(object), label)
  4: eval_bare(get_expr(quo), get_env(quo))
  5: input_tbl %>% expose(input_rule_pack, .guess = TRUE)
  6: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  7: eval(quote(`_fseq`(`_lhs`)), env, env)
  8: eval(quote(`_fseq`(`_lhs`)), env, env)
  9: `_fseq`(`_lhs`)
  10: freduce(value, `_function_list`)
  ...
  22: withVisible(function_list[[k]](value))
  23: function_list[[k]](value)
  24: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100))
  25: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  26: as_fun_list(.funs, .quo, .env, ...)
  27: is_fun_list(.x)
  28: rules(tot_sum = sum(.) > 100)
  29: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  30: rlang::UQS(dots)
  31: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 5. Error: expose_single.default guesses col pack (@test-expose.R#309)  ──────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_expose_single_default_works(.tbl = input_tbl_keyed, .pack = input_col_pack, 
         .report_with_remove = input_col_pack_report_with_remove, .report_no_remove = input_col_pack_report_no_remove) at testthat/test-expose.R:309
  2: expect_expose_single_works(.tbl = .tbl, .pack = .pack, .used_pack = input_rule_pack, 
         .rule_sep = .rule_sep, .report_with_remove = .report_with_remove, .report_no_remove = .report_no_remove) at testthat/test-expose.R:109
  3: expect_identical(expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, 
         .remove_obeyers = TRUE, .guess = TRUE), output_ref_remove) at testthat/test-expose.R:74
  4: quasi_label(enquo(object), label)
  5: eval_bare(get_expr(quo), get_env(quo))
  6: expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  7: expose_single.default(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  8: .pack(.tbl)
  9: freduce(value, `_function_list`)
  10: withVisible(function_list[[k]](value))
  11: function_list[[k]](value)
  12: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100))
  13: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  14: as_fun_list(.funs, .quo, .env, ...)
  15: is_fun_list(.x)
  16: rules(tot_sum = sum(.) > 100)
  17: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  18: rlang::UQS(dots)
  19: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 6. Error: expose_single.default guesses cell pack (@test-expose.R#335)  ─────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_expose_single_default_works(.tbl = input_tbl_keyed, .pack = input_cell_pack, 
         .report_with_remove = input_cell_pack_report_with_remove, .report_no_remove = input_cell_pack_report_no_remove) at testthat/test-expose.R:335
  2: expect_expose_single_works(.tbl = .tbl, .pack = .pack, .used_pack = input_rule_pack, 
         .rule_sep = .rule_sep, .report_with_remove = .report_with_remove, .report_no_remove = .report_no_remove) at testthat/test-expose.R:109
  3: expect_identical(expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, 
         .remove_obeyers = TRUE, .guess = TRUE), output_ref_remove) at testthat/test-expose.R:74
  4: quasi_label(enquo(object), label)
  5: eval_bare(get_expr(quo), get_env(quo))
  6: expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  7: expose_single.default(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  8: .pack(.tbl)
  9: freduce(value, `_function_list`)
  10: withVisible(function_list[[k]](value))
  11: function_list[[k]](value)
  12: dplyr::transmute_if(., Negate(rlang::is_integerish), rules(abs(. - mean(.))/sd(.) < 
         2))
  13: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  14: as_fun_list(.funs, .quo, .env, ...)
  15: is_fun_list(.x)
  16: rules(abs(. - mean(.))/sd(.) < 2)
  17: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  18: rlang::UQS(dots)
  19: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 7. Error: expose_single.col_pack works (@test-expose.R#402)  ────────────────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_expose_single_works(.tbl = input_tbl_keyed, .pack = input_col_pack, .report_with_remove = input_col_pack_report_with_remove, 
         .report_no_remove = input_col_pack_report_no_remove) at testthat/test-expose.R:402
  2: expect_identical(expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, 
         .remove_obeyers = TRUE, .guess = TRUE), output_ref_remove) at testthat/test-expose.R:74
  3: quasi_label(enquo(object), label)
  4: eval_bare(get_expr(quo), get_env(quo))
  5: expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  6: expose_single.col_pack(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  7: .tbl %>% .pack() %>% interp_col_pack_out(.rule_sep = .rule_sep) %>% remove_obeyers(.do_remove = .remove_obeyers)
  8: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  9: eval(quote(`_fseq`(`_lhs`)), env, env)
  10: eval(quote(`_fseq`(`_lhs`)), env, env)
  ...
  16: withVisible(function_list[[k]](value))
  17: function_list[[k]](value)
  18: dplyr::summarise_if(., rlang::is_integerish, rules(tot_sum = sum(.) > 100))
  19: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  20: as_fun_list(.funs, .quo, .env, ...)
  21: is_fun_list(.x)
  22: rules(tot_sum = sum(.) > 100)
  23: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  24: rlang::UQS(dots)
  25: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 8. Error: expose_single.cell_pack works (@test-expose.R#453)  ───────────────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_expose_single_works(.tbl = input_tbl_keyed, .pack = input_cell_pack, .report_with_remove = input_cell_pack_report_with_remove, 
         .report_no_remove = input_cell_pack_report_no_remove) at testthat/test-expose.R:453
  2: expect_identical(expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, 
         .remove_obeyers = TRUE, .guess = TRUE), output_ref_remove) at testthat/test-expose.R:74
  3: quasi_label(enquo(object), label)
  4: eval_bare(get_expr(quo), get_env(quo))
  5: expose_single(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  6: expose_single.cell_pack(.tbl = .tbl, .pack = .used_pack, .rule_sep = .rule_sep, .remove_obeyers = TRUE, 
         .guess = TRUE)
  7: .tbl %>% .pack() %>% interp_cell_pack_out(.rule_sep = .rule_sep) %>% remove_obeyers(.do_remove = .remove_obeyers)
  8: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  9: eval(quote(`_fseq`(`_lhs`)), env, env)
  10: eval(quote(`_fseq`(`_lhs`)), env, env)
  ...
  16: withVisible(function_list[[k]](value))
  17: function_list[[k]](value)
  18: dplyr::transmute_if(., Negate(rlang::is_integerish), rules(abs(. - mean(.))/sd(.) < 
         2))
  19: manip_if(.tbl, .predicate, .funs, enquo(.funs), caller_env(), ...)
  20: as_fun_list(.funs, .quo, .env, ...)
  21: is_fun_list(.x)
  22: rules(abs(. - mean(.))/sd(.) < 2)
  23: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  24: rlang::UQS(dots)
  25: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ── 9. Error: rules works (@test-rules.R#6)  ────────────────────────────────────
  `UQS()` can only be used within a quasiquoted argument
  1: expect_identical(rules(), funs()) at testthat/test-rules.R:6
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: rules()
  5: do.call(what = dplyr::funs, args = c(rlang::UQS(dots), list(.args = .args)), envir = rlang::caller_env())
  6: rlang::UQS(dots)
  7: abort("`UQS()` can only be used within a quasiquoted argument")
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 269 SKIPPED: 0 FAILED: 9
  1. Error: expose works (@test-expose.R#162) 
  2. Error: expose preserves pack names (@test-expose.R#218) 
  3. Error: expose accounts for rule separator (@test-expose.R#250) 
  4. Error: expose guesses (@test-expose.R#269) 
  5. Error: expose_single.default guesses col pack (@test-expose.R#309) 
  6. Error: expose_single.default guesses cell pack (@test-expose.R#335) 
  7. Error: expose_single.col_pack works (@test-expose.R#402) 
  8. Error: expose_single.cell_pack works (@test-expose.R#453) 
  9. Error: rules works (@test-rules.R#6) 
  
  Error: testthat unit tests failed
  Execution halted