Running ‘testInteractive.R’
  Running ‘testthat.R’
Running the tests in ‘tests/testInteractive.R’ failed.
Complete output:
  > library(htmlTable)
  > 
  > interactiveTable(matrix(c("asdsadadadas",
  +                           "DSASDS  asd as dasd ad ads dasd dsa ADSADASDASD"), ncol = 2),
  +                  minimized.columns = 2)
  Error in qassert(null.ok, "B1") : 
    LOGICAL() can only be applied to a 'logical', not a 'language'
  Calls: interactiveTable ... htmlTable.default -> assert -> assertChoice -> checkChoice -> qassert
  Execution halted
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library('testthat')
  > 
  > test_check('htmlTable')
  Loading required package: htmlTable
  ── 1. Error: First dimname should be converted to rgroup, tspanner or rowlabel (
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: table(var1, var2) %>% htmlTable(css.rgroup = "background: blue") at testthat/test-htmlTable-dimnames.R:8
  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: htmlTable(., css.rgroup = "background: blue")
  10: htmlTable.default(., css.rgroup = "background: blue")
  11: assert(check_matrix(css.cell), check_character(css.cell))
  12: assertChoice(combine, c("or", "and"))
  13: checkChoice(x, choices, null.ok, fmatch)
  14: qassert(null.ok, "B1")
  
  ── 2. Error: Second dimname should be converted to cgroup (@test-htmlTable-dimna
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: table(var1, var2) %>% htmlTable at testthat/test-htmlTable-dimnames.R:58
  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: htmlTable(.)
  10: htmlTable.default(.)
  11: assert(check_matrix(css.cell), check_character(css.cell))
  12: assertChoice(combine, c("or", "and"))
  13: checkChoice(x, choices, null.ok, fmatch)
  14: qassert(null.ok, "B1")
  
  ── 3. Error: Check inputs (@test-htmlTable-input_checks.R#10)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, css.cell = css.cell) at testthat/test-htmlTable-input_checks.R:10
  2: htmlTable.matrix(mx, css.cell = css.cell)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 4. Error: With empty rownames(mx) it should skip those (@test-htmlTable.R#9) 
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx) at testthat/test-htmlTable.R:9
  2: htmlTable.matrix(mx)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 5. Error: Empty cell names should be replaced with '' (@test-htmlTable.R#24) 
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx) at testthat/test-htmlTable.R:24
  2: htmlTable.matrix(mx)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 6. Error: The variable name should not be in the tables first row if no rowna
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx) at testthat/test-htmlTable.R:32
  2: htmlTable.matrix(mx)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 7. Error: The rowname should appear (@test-htmlTable.R#49)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx) at testthat/test-htmlTable.R:49
  2: htmlTable.matrix(mx)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 8. Error: Check that basic output are the same as the provided matrix (@test-
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx) at testthat/test-htmlTable.R:60
  2: htmlTable.matrix(mx)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 9. Error: rnames = FALSE it should skip those (@test-htmlTable.R#74)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, rnames = FALSE) at testthat/test-htmlTable.R:74
  2: htmlTable.matrix(mx, rnames = FALSE)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 10. Error: Test align functions (@test-htmlTable.R#147)  ────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, rname = FALSE) at testthat/test-htmlTable.R:147
  2: htmlTable.matrix(mx, rname = FALSE)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 11. Error: Handling data.frames with factors (@test-htmlTable.R#299)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: htmlTable(tmp) at testthat/test-htmlTable.R:299
  2: htmlTable.data.frame(tmp)
  3: htmlTable.default(prConvertDfFactors(x), ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 12. Error: has header elements (@test-htmlTable.R#314)  ─────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: expect_warning({
         table_str <- htmlTable(empty_dataframe)
     }) at testthat/test-htmlTable.R:314
  2: quasi_capture(enquo(object), capture_warnings, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, warning = function(condition) {
         out$push(condition)
         invokeRestart("muffleWarning")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: htmlTable(empty_dataframe) at testthat/test-htmlTable.R:315
  7: htmlTable.data.frame(empty_dataframe)
  8: htmlTable.default(prConvertDfFactors(x), ...)
  9: assert(check_matrix(css.cell), check_character(css.cell))
  10: assertChoice(combine, c("or", "and"))
  11: checkChoice(x, choices, null.ok, fmatch)
  12: qassert(null.ok, "B1")
  
  ── 13. Error: An empty dataframe returns an empty table with a warning (@test-ht
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: expect_warning(htmlTable(empty_dataframe), regexp = "empty_dataframe") at testthat/test-htmlTable.R:344
  2: quasi_capture(enquo(object), capture_warnings, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, warning = function(condition) {
         out$push(condition)
         invokeRestart("muffleWarning")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: htmlTable(empty_dataframe)
  7: htmlTable.data.frame(empty_dataframe)
  8: htmlTable.default(prConvertDfFactors(x), ...)
  9: assert(check_matrix(css.cell), check_character(css.cell))
  10: assertChoice(combine, c("or", "and"))
  11: checkChoice(x, choices, null.ok, fmatch)
  12: qassert(null.ok, "B1")
  
  ── 14. Error: HTML code is properly escaped (@test-htmlTable.R#387)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: expect_match(object = htmlTable(data.frame(a = "<3"), rnames = FALSE, escape.html = TRUE), 
         regexp = "&lt;3") at testthat/test-htmlTable.R:387
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: htmlTable(data.frame(a = "<3"), rnames = FALSE, escape.html = TRUE)
  5: htmlTable.data.frame(data.frame(a = "<3"), rnames = FALSE, escape.html = TRUE)
  6: htmlTable.default(prConvertDfFactors(x), ...)
  7: assert(check_matrix(css.cell), check_character(css.cell))
  8: assertChoice(combine, c("or", "and"))
  9: checkChoice(x, choices, null.ok, fmatch)
  10: qassert(null.ok, "B1")
  
  ── 15. Error: Check that dimensions are correct with cgroup usage (@test-htmlTab
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, cgroup = c("a", "b"), n.cgroup = c(1, 2)) at testthat/test-htmlTable_cgroup.R:9
  2: htmlTable.matrix(mx, cgroup = c("a", "b"), n.cgroup = c(1, 2))
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 16. Error: Flexible number of cgroups (@test-htmlTable_cgroup.R#108)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, cgroup = c("", "__test__"), n.cgroup = 1) at testthat/test-htmlTable_cgroup.R:108
  2: htmlTable.matrix(mx, cgroup = c("", "__test__"), n.cgroup = 1)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 17. Error: Assume last element for n.cgroup (@test-htmlTable_cgroup.R#120)  ─
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, cgroup = "__test__") at testthat/test-htmlTable_cgroup.R:120
  2: htmlTable.matrix(mx, cgroup = "__test__")
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 18. Error: should be converted into strings (@test-htmlTable_dates.R#45)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: htmlTable(df_dates, rnames = FALSE) at testthat/test-htmlTable_dates.R:45
  2: htmlTable.data.frame(df_dates, rnames = FALSE)
  3: htmlTable.default(prConvertDfFactors(x), ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 19. Error: Check that rgroup has the appropriate padding (@test-htmlTable_rgr
  LOGICAL() can only be applied to a 'logical', not a 'unknown type #28'
  1: htmlTable(mx, rgroup = paste("rgroup", 1:2), n.rgroup = rep(1, 2)) at testthat/test-htmlTable_rgroup_tspanner.R:11
  2: htmlTable.matrix(mx, rgroup = paste("rgroup", 1:2), n.rgroup = rep(1, 2))
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 20. Error: Check that dimensions are correct with rgroup usage (@test-htmlTab
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: suppressWarnings(htmlTable(mx, rgroup = c("test1", "test2"), n.rgroup = c(1, 1))) at testthat/test-htmlTable_rgroup_tspanner.R:46
  2: withCallingHandlers(expr, warning = function(w) invokeRestart("muffleWarning"))
  3: htmlTable(mx, rgroup = c("test1", "test2"), n.rgroup = c(1, 1))
  4: htmlTable.matrix(mx, rgroup = c("test1", "test2"), n.rgroup = c(1, 1))
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 21. Error: Check rgroup attribute (@test-htmlTable_rgroup_tspanner.R#95)  ───
  LOGICAL() can only be applied to a 'logical', not a 'unknown type #28'
  1: expect_match(htmlTable(mx, rgroup = rgroup, n.rgroup = rep(1, 2)), "<td[^>]+colspan[ ]*=[ ]*'3'[^>]+>rgroup 1</td>[^<]*<td[^>]*>test 1") at testthat/test-htmlTable_rgroup_tspanner.R:95
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: htmlTable(mx, rgroup = rgroup, n.rgroup = rep(1, 2))
  5: htmlTable.matrix(mx, rgroup = rgroup, n.rgroup = rep(1, 2))
  6: htmlTable.default(x, total = total, ...)
  7: assert(check_matrix(css.cell), check_character(css.cell))
  8: assertChoice(combine, c("or", "and"))
  9: checkChoice(x, choices, null.ok, fmatch)
  10: qassert(null.ok, "B1")
  
  ── 22. Error: Check rgroup attribute without CSS (@test-htmlTable_rgroup_tspanne
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: expect_match(htmlTable(mx, rgroup = rgroup, n.rgroup = rep(1, 2), css.rgroup = ""), 
         "<td[^>]+>rgroup 1</td>[^<]*<td[^>]*>test d</td>") at testthat/test-htmlTable_rgroup_tspanner.R:157
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: htmlTable(mx, rgroup = rgroup, n.rgroup = rep(1, 2), css.rgroup = "")
  5: htmlTable.matrix(mx, rgroup = rgroup, n.rgroup = rep(1, 2), css.rgroup = "")
  6: htmlTable.default(x, total = total, ...)
  7: assert(check_matrix(css.cell), check_character(css.cell))
  8: assertChoice(combine, c("or", "and"))
  9: checkChoice(x, choices, null.ok, fmatch)
  10: qassert(null.ok, "B1")
  
  ── 23. Error: Check rgroup attribute with matrix (@test-htmlTable_rgroup_tspanne
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, rgroup = rgroup, n.rgroup = c(1, 1), css.rgroup = "") at testthat/test-htmlTable_rgroup_tspanner.R:170
  2: htmlTable.matrix(mx, rgroup = rgroup, n.rgroup = c(1, 1), css.rgroup = "")
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 24. Error: Matrix with rownames and rgroup with 1 element (@test-htmlTable_rg
  LOGICAL() can only be applied to a 'logical', not a 'pairlist'
  1: expect_silent(htmlTable(a, rgroup = LETTERS[1:2], n.rgroup = c(1, 1), caption = "Site for UVR & Visibility for any mortality indicating melanoma")) at testthat/test-htmlTable_rgroup_tspanner.R:237
  2: quasi_capture(enquo(object), evaluate_promise)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withr::with_output_sink(temp, withCallingHandlers(withVisible(code), warning = handle_warning, 
         message = handle_message))
  5: force(code)
  6: withCallingHandlers(withVisible(code), warning = handle_warning, message = handle_message)
  7: withVisible(code)
  8: eval_bare(get_expr(quo), get_env(quo))
  9: htmlTable(a, rgroup = LETTERS[1:2], n.rgroup = c(1, 1), caption = "Site for UVR & Visibility for any mortality indicating melanoma")
  10: htmlTable.matrix(a, rgroup = LETTERS[1:2], n.rgroup = c(1, 1), caption = "Site for UVR & Visibility for any mortality indicating melanoma")
  11: htmlTable.default(x, total = total, ...)
  12: assert(check_matrix(css.cell), check_character(css.cell))
  13: assertChoice(combine, c("or", "and"))
  14: checkChoice(x, choices, null.ok, fmatch)
  15: qassert(null.ok, "B1")
  
  ── 25. Error: Check that row styles are present (@test-htmlTable_styles.R#27)  ─
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, css.cell = css.cell, cgroup = c("Cgroup 1", "Cgroup 2"), n.cgroup = c(2, 
         4)) at testthat/test-htmlTable_styles.R:27
  2: htmlTable.matrix(mx, css.cell = css.cell, cgroup = c("Cgroup 1", "Cgroup 2"), n.cgroup = c(2, 
         4))
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 26. Error: Correct rows (@test-htmlTable_total.R#16)  ───────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: htmlTable(mx, css.total = "color: red", total = TRUE) at testthat/test-htmlTable_total.R:16
  2: htmlTable.matrix(mx, css.total = "color: red", total = TRUE)
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 27. Error: Check tspanner (@test-htmlTable_total.R#43)  ─────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'unknown type #28'
  1: htmlTable(mx, tspanner = letters[1:2], n.tspanner = c(3, 3), css.total = "color: red", 
         total = "tspanner") at testthat/test-htmlTable_total.R:43
  2: htmlTable.matrix(mx, tspanner = letters[1:2], n.tspanner = c(3, 3), css.total = "color: red", 
         total = "tspanner")
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 28. Error: Check choosing css.style (@test-htmlTable_total.R#53)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'unknown type #28'
  1: htmlTable(mx, tspanner = letters[1:2], n.tspanner = c(3, 3), css.total = c("color: red", 
         "color: green"), total = "tspanner") at testthat/test-htmlTable_total.R:53
  2: htmlTable.matrix(mx, tspanner = letters[1:2], n.tspanner = c(3, 3), css.total = c("color: red", 
         "color: green"), total = "tspanner")
  3: htmlTable.default(x, total = total, ...)
  4: assert(check_matrix(css.cell), check_character(css.cell))
  5: assertChoice(combine, c("or", "and"))
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 29. Error: The total should be added to the output if used with addmargins (@
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: table(var1, var2) %>% addmargins %>% htmlTable(css.total = "background: purple") at testthat/test-htmlTable_total.R:64
  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: htmlTable(., css.total = "background: purple")
  10: htmlTable.matrix(., css.total = "background: purple")
  11: htmlTable.default(x, total = total, ...)
  12: assert(check_matrix(css.cell), check_character(css.cell))
  13: assertChoice(combine, c("or", "and"))
  14: checkChoice(x, choices, null.ok, fmatch)
  15: qassert(null.ok, "B1")
  
  ── 30. Error: With empty rownames(mx) it should skip those (@test-interactiveTab
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx) at testthat/test-interactiveTable.R:9
  2: interactiveTable.default(mx)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 31. Error: Empty cell names should be replaced with '' (@test-interactiveTabl
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx) at testthat/test-interactiveTable.R:24
  2: interactiveTable.default(mx)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 32. Error: The variable name should not be in the tables first row if no rown
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx) at testthat/test-interactiveTable.R:32
  2: interactiveTable.default(mx)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 33. Error: The rowname should appear (@test-interactiveTable.R#49)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx) at testthat/test-interactiveTable.R:49
  2: interactiveTable.default(mx)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 34. Error: Check that basic output are the same as the provided matrix (@test
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx) at testthat/test-interactiveTable.R:61
  2: interactiveTable.default(mx)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 35. Error: rnames = FALSE it should skip those (@test-interactiveTable.R#76) 
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx, rnames = FALSE) at testthat/test-interactiveTable.R:76
  2: interactiveTable.default(mx, rnames = FALSE)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 36. Error: Test align functions (@test-interactiveTable.R#149)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'language'
  1: interactiveTable(mx, rname = FALSE) at testthat/test-interactiveTable.R:149
  2: interactiveTable.default(mx, rname = FALSE)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.matrix(x, escape.html = FALSE, ...)
  5: htmlTable.default(x, total = total, ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ── 37. Error: Handling data.frames with factors (@test-interactiveTable.R#301)  
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: interactiveTable(tmp) at testthat/test-interactiveTable.R:301
  2: interactiveTable.default(tmp)
  3: htmlTable(x, escape.html = FALSE, ...)
  4: htmlTable.data.frame(x, escape.html = FALSE, ...)
  5: htmlTable.default(prConvertDfFactors(x), ...)
  6: assert(check_matrix(css.cell), check_character(css.cell))
  7: assertChoice(combine, c("or", "and"))
  8: checkChoice(x, choices, null.ok, fmatch)
  9: qassert(null.ok, "B1")
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 227 SKIPPED: 0 FAILED: 37
  1. Error: First dimname should be converted to rgroup, tspanner or rowlabel (@test-htmlTable-dimnames.R#8) 
  2. Error: Second dimname should be converted to cgroup (@test-htmlTable-dimnames.R#58) 
  3. Error: Check inputs (@test-htmlTable-input_checks.R#10) 
  4. Error: With empty rownames(mx) it should skip those (@test-htmlTable.R#9) 
  5. Error: Empty cell names should be replaced with '' (@test-htmlTable.R#24) 
  6. Error: The variable name should not be in the tables first row if no rownames(mx) (@test-htmlTable.R#32) 
  7. Error: The rowname should appear (@test-htmlTable.R#49) 
  8. Error: Check that basic output are the same as the provided matrix (@test-htmlTable.R#60) 
  9. Error: rnames = FALSE it should skip those (@test-htmlTable.R#74) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted