Running ‘testthat.R’ [27s/38s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(interactions)
  > 
  > test_check("interactions")
  ── 1. Error: cat_plot handles simple plot (bar) (@test_cat_plot.R#20)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:20
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 2. Error: cat_plot handles intervals (bar) (@test_cat_plot.R#25)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:25
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 3. Error: cat_plot handles plotted points (bar) (@test_cat_plot.R#31)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:31
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 4. Error: cat_plot handles simple plot (line) (@test_cat_plot.R#36)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:36
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 5. Error: cat_plot handles intervals (line) (@test_cat_plot.R#42)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:42
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 6. Error: cat_plot handles plotted points (line) (@test_cat_plot.R#48)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:48
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 7. Error: cat_plot handles point.shape (line) (@test_cat_plot.R#54)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:54
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 8. Error: cat_plot handles point.shape (line) (@test_cat_plot.R#61)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:61
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 9. Error: cat_plot handles simple plot (point) (@test_cat_plot.R#66)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:66
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 10. Error: cat_plot handles intervals (point) (@test_cat_plot.R#72)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:72
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 11. Error: cat_plot handles plotted points (point) (@test_cat_plot.R#78)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:78
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 12. Error: cat_plot handles point.shape (point) (@test_cat_plot.R#85)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:85
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 13. Error: cat_plot handles offsets (@test_cat_plot.R#106)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:106
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 14. Error: cat_plot handles svyglm (@test_cat_plot.R#119)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:119
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 15. Error: cat_plot handles merMod (@test_cat_plot.R#127)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:127
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 16. Error: cat_plot does 3-way interactions (bar) (@test_cat_plot.R#150)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:150
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 17. Error: cat_plot does intervals w/ 3-way interactions (bar) (@test_cat_plo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:156
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 18. Error: cat_plot does plot.points w/ 3-way interactions (bar) (@test_cat_p
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:162
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 19. Error: cat_plot does point.shape w/ 3-way interactions (bar) (@test_cat_p
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:168
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 20. Error: cat_plot does 3-way interactions (line) (@test_cat_plot.R#173)  ──
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:173
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 21. Error: cat_plot does intervals w/ 3-way interactions (line) (@test_cat_pl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:179
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 22. Error: cat_plot does plot.points w/ 3-way interactions (line) (@test_cat_
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:185
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 23. Error: cat_plot does point.shape w/ 3-way interactions (line) (@test_cat_
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:191
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 24. Error: cat_plot does vary.lty w/ 3-way interactions (line) (@test_cat_plo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:198
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 25. Error: cat_plot does 3-way interactions (point) (@test_cat_plot.R#203)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:203
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 26. Error: cat_plot does intervals w/ 3-way interactions (point) (@test_cat_p
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:209
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 27. Error: cat_plot does plot.points w/ 3-way interactions (point) (@test_cat
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:215
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 28. Error: cat_plot does point.shape w/ 3-way interactions (point) (@test_cat
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:221
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 29. Error: cat_plot does 3-way interactions (line) (@test_cat_plot.R#226)  ──
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:226
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 30. Error: cat_plot does plot.points w/ 3-way interactions (line) (@test_cat_
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:232
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(col_vars, row_vars, params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 31. Error: cat_plot handles simple plot w/ no mod. (bar) (@test_cat_plot.R#23
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:239
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 32. Error: cat_plot handles intervals w/ no mod. (bar) (@test_cat_plot.R#244)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:244
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 33. Error: cat_plot handles plotted points w/ no mod. (bar) (@test_cat_plot.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:250
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 34. Error: cat_plot handles simple plot w/ no mod. (point) (@test_cat_plot.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:255
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 35. Error: cat_plot handles intervals w/ no mod. (point) (@test_cat_plot.R#26
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:261
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 36. Error: cat_plot handles plotted points w/ no mod. (point) (@test_cat_plot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:267
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 37. Error: cat_plot handles point.shape w/ no mod. (point) (@test_cat_plot.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_cat_plot.R:274
  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: print(p)
  10: print.ggplot(p)
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 38. Error: brmsfit objects are supported (@test_cat_plot.R#281)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(cat_plot(bfit, pred = "Trt", interval = TRUE))) at testthat/test_cat_plot.R:281
  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: print(cat_plot(bfit, pred = "Trt", interval = TRUE))
  10: print.ggplot(cat_plot(bfit, pred = "Trt", interval = TRUE))
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 39. Error: interact_plot works for lm (@test_interact_plot.R#38)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:38
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 40. Error: interact_plot: robust standard errors work (@test_interact_plot.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:66
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 41. Error: rug plots work (@test_interact_plot.R#76)  ───────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:76
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 42. Error: interact_plot works for weighted lm (@test_interact_plot.R#95)  ──
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:95
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 43. Error: interact_plot works for lm w/ logical (@test_interact_plot.R#102) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:102
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 44. Error: interact_plot works for lm w/ non-focal character (@test_interact_
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:113
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 45. Error: interact_plot accepts user-specified values and labels (@test_inte
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:126
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 46. Error: interact_plot terciles modxval/mod2val works (@test_interact_plot.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:146
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 47. Error: interact_plot linearity.check works (@test_interact_plot.R#156)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:156
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 48. Error: interact_plot works for svyglm (@test_interact_plot.R#171)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:171
  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: print(p)
  10: print.ggplot(p)
  11: ggplot_gtable(data)
  12: ggplot_gtable.ggplot_built(data)
  13: layout$render(geom_grobs, data, theme, plot$labels)
  14: f(..., self = self)
  15: self$facet$draw_panels(panels, self$layout, self$panel_scales_x, self$panel_scales_y, 
         self$panel_params, self$coord, data, theme, self$facet_params)
  16: f(...)
  17: render_strips(structure(labels_df, type = "rows"), structure(labels_df, type = "cols"), 
         params$labeller, theme)
  18: build_strip(x, labeller, theme, TRUE)
  19: ggstrip(grobs, theme, element, gp, horizontal, clip = "on")
  20: Summary.unit(structure(c(5, 5), unit = 8L, class = c("margin", "unit")), na.rm = FALSE)
  
  ── 49. Error: interact_plot works for lme4 (@test_interact_plot.R#195)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:195
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 50. Error: interact_plot handles offsets (@test_interact_plot.R#216)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:216
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 51. Error: interact_plot handles offsets with robust SE (@test_interact_plot.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test_interact_plot.R:222
  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: print(p)
  10: print.ggplot(p)
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 52. Error: brmsfit objects are supported (@test_interact_plot.R#252)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(cat_plot(bfit, pred = "Trt", interval = TRUE))) at testthat/test_interact_plot.R:252
  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: print(cat_plot(bfit, pred = "Trt", interval = TRUE))
  10: print.ggplot(cat_plot(bfit, pred = "Trt", interval = TRUE))
  ...
  15: preDraw(x)
  16: preDraw.gTree(x)
  17: pushvpgp(x)
  18: pushgrobvp(x$vp)
  19: pushgrobvp.viewport(x$vp)
  20: pushViewport(vp, recording = FALSE)
  21: lapply(vps, push.vp, recording)
  22: FUN(X[[i]], ...)
  23: push.vp.viewport(X[[i]], ...)
  24: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 53. Error: stanreg objects are supported (@test_interact_plot.R#265)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(interact_plot(rsfit, pred = "size", modx = "period", interval = TRUE, 
         data = cbpp))) at testthat/test_interact_plot.R:265
  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: print(interact_plot(rsfit, pred = "size", modx = "period", interval = TRUE, data = cbpp))
  10: print.ggplot(interact_plot(rsfit, pred = "size", modx = "period", interval = TRUE, 
         data = cbpp))
  ...
  24: pushvpgp(x)
  25: pushgrobvp(x$vp)
  26: pushgrobvp.viewport(x$vp)
  27: pushViewport(vp, recording = FALSE)
  28: lapply(vps, push.vp, recording)
  29: FUN(X[[i]], ...)
  30: push.vp.vpTree(X[[i]], ...)
  31: push.vp(vp$parent, recording)
  32: push.vp.viewport(vp$parent, recording)
  33: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 71 SKIPPED: 0 FAILED: 53
  1. Error: cat_plot handles simple plot (bar) (@test_cat_plot.R#20) 
  2. Error: cat_plot handles intervals (bar) (@test_cat_plot.R#25) 
  3. Error: cat_plot handles plotted points (bar) (@test_cat_plot.R#31) 
  4. Error: cat_plot handles simple plot (line) (@test_cat_plot.R#36) 
  5. Error: cat_plot handles intervals (line) (@test_cat_plot.R#42) 
  6. Error: cat_plot handles plotted points (line) (@test_cat_plot.R#48) 
  7. Error: cat_plot handles point.shape (line) (@test_cat_plot.R#54) 
  8. Error: cat_plot handles point.shape (line) (@test_cat_plot.R#61) 
  9. Error: cat_plot handles simple plot (point) (@test_cat_plot.R#66) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted