Running ‘testthat.R’ [33s/35s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(jtools)
  > 
  > 
  > test_check("jtools")
  ── 1. Error: effect_plot works for lm (@test-effect-plot.R#28)  ────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:28
  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)
  
  ── 2. Error: effect_plot: robust intervals works (@test-effect-plot.R#41)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:41
  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)
  
  ── 3. Error: effect_plot: rug plots work (@test-effect-plot.R#49)  ─────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:49
  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)
  
  ── 4. Error: effect_plot: plot.points works (@test-effect-plot.R#64)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:64
  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)
  
  ── 5. Error: effect_plot: partial residuals work (@test-effect-plot.R#79)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:79
  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)
  
  ── 6. Error: effect_plot works for weighted lm (@test-effect-plot.R#92)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:92
  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)
  
  ── 7. Error: effect_plot works for svyglm (@test-effect-plot.R#136)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:136
  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)
  
  ── 8. Error: effect_plot works for lme4 (@test-effect-plot.R#167)  ─────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:167
  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)
  
  ── 9. Error: effect_plot handles offsets (@test-effect-plot.R#207)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:207
  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)
  
  ── 10. Error: effect_plot handles plot points with offsets (@test-effect-plot.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:213
  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)
  
  ── 11. Error: effect_plot handles partial residuals with offsets (@test-effect-p
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:220
  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)
  
  ── 12. Error: effect_plot handles offsets w/ categorical predictors (@test-effec
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:229
  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)
  
  ── 13. Error: effect_plot does line plots (@test-effect-plot.R#243)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:243
  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: effect_plot does bar plots (@test-effect-plot.R#254)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-effect-plot.R:254
  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: brmsfit objects are supported (@test-effect-plot.R#284)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(effect_plot(bfit, pred = "log_Base4_c", interval = TRUE) + ggtitle("brms"))) at testthat/test-effect-plot.R:284
  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(effect_plot(bfit, pred = "log_Base4_c", interval = TRUE) + ggtitle("brms"))
  10: print.ggplot(effect_plot(bfit, pred = "log_Base4_c", interval = TRUE) + ggtitle("brms"))
  ...
  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)
  
  ── 16. Error: stanreg objects are supported (@test-effect-plot.R#302)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_message(print(effect_plot(rsfit, pred = "size", interval = TRUE) + ggtitle("stanreg"))) at testthat/test-effect-plot.R:302
  2: quasi_capture(enquo(object), capture_messages, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, message = function(condition) {
         out$push(condition)
         invokeRestart("muffleMessage")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: print(effect_plot(rsfit, pred = "size", interval = TRUE) + ggtitle("stanreg"))
  7: print.ggplot(effect_plot(rsfit, pred = "size", interval = TRUE) + ggtitle("stanreg"))
  8: grid.draw(gtable)
  9: grid.draw.gTree(gtable)
  10: recordGraphics(drawGTree(x), list(x = x), getNamespace("grid"))
  11: drawGTree(x)
  12: preDraw(x)
  13: preDraw.gTree(x)
  14: pushvpgp(x)
  15: pushgrobvp(x$vp)
  16: pushgrobvp.viewport(x$vp)
  17: pushViewport(vp, recording = FALSE)
  18: lapply(vps, push.vp, recording)
  19: FUN(X[[i]], ...)
  20: push.vp.viewport(X[[i]], ...)
  21: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 17. Error: plot_summs doesn't fail with lm (@test-export-summs.R#181)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:181
  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)
  
  ── 18. Error: plot_summs accepts summ args with lm (@test-export-summs.R#188)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:188
  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)
  
  ── 19. Error: plot_summs works with glm (@test-export-summs.R#193)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:193
  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)
  
  ── 20. Error: plot_summs accepts summ args with glm (@test-export-summs.R#199)  
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:199
  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)
  
  ── 21. Error: plot_summs accepts odds ratios with glm (@test-export-summs.R#206)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:206
  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)
  
  ── 22. Error: plot_summs works with svyglm (@test-export-summs.R#212)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:212
  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)
  
  ── 23. Error: plot_summs accepts summ args with svyglm (@test-export-summs.R#217
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:217
  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)
  
  ── 24. Error: plot_summs works with lmer (@test-export-summs.R#224)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:224
  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)
  
  ── 25. Error: plot_summs accepts summ args with lmer (@test-export-summs.R#229) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:229
  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)
  
  ── 26. Error: plot_summs can take manual coefficient names (@test-export-summs.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.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: 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)
  
  ── 27. Error: plot_summs can omit coefficients (@test-export-summs.R#243)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:243
  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)
  
  ── 28. Error: plot_summs can facet (@test-export-summs.R#250)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.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)
  ...
  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)
  
  ── 29. Error: plot_coefs works (@test-export-summs.R#258)  ─────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:258
  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)
  
  ── 30. Error: plot_coefs can take manual coefficient names (@test-export-summs.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.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(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)
  
  ── 31. Error: plot_coefs can omit coefficients (@test-export-summs.R#271)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(p)) at testthat/test-export-summs.R:271
  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)
  
  ── 32. Error: inner_ci_level works (@test-export-summs.R#275)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(plot_coefs(fit, fitw, inner_ci_level = 0.9))) at testthat/test-export-summs.R:275
  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(plot_coefs(fit, fitw, inner_ci_level = 0.9))
  10: print.ggplot(plot_coefs(fit, fitw, inner_ci_level = 0.9))
  ...
  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)
  
  ── 33. Error: plot.distributions works (@test-export-summs.R#279)  ─────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_message(print(plot_coefs(fit, plot.distributions = TRUE))) at testthat/test-export-summs.R:279
  2: quasi_capture(enquo(object), capture_messages, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, message = function(condition) {
         out$push(condition)
         invokeRestart("muffleMessage")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: print(plot_coefs(fit, plot.distributions = TRUE))
  7: print.ggplot(plot_coefs(fit, plot.distributions = TRUE))
  8: grid.draw(gtable)
  9: grid.draw.gTree(gtable)
  10: recordGraphics(drawGTree(x), list(x = x), getNamespace("grid"))
  11: drawGTree(x)
  12: preDraw(x)
  13: preDraw.gTree(x)
  14: pushvpgp(x)
  15: pushgrobvp(x$vp)
  16: pushgrobvp.viewport(x$vp)
  17: pushViewport(vp, recording = FALSE)
  18: lapply(vps, push.vp, recording)
  19: FUN(X[[i]], ...)
  20: push.vp.viewport(X[[i]], ...)
  21: grid.Call.graphics(C_setviewport, vp, TRUE)
  
  ── 34. Error: rq plotters work (@test-quantreg.R#42)  ──────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_silent(print(effect_plot(rfit, pred = "Air.Flow", interval = TRUE))) at testthat/test-quantreg.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(effect_plot(rfit, pred = "Air.Flow", interval = TRUE))
  10: print.ggplot(effect_plot(rfit, pred = "Air.Flow", 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)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 268 SKIPPED: 0 FAILED: 34
  1. Error: effect_plot works for lm (@test-effect-plot.R#28) 
  2. Error: effect_plot: robust intervals works (@test-effect-plot.R#41) 
  3. Error: effect_plot: rug plots work (@test-effect-plot.R#49) 
  4. Error: effect_plot: plot.points works (@test-effect-plot.R#64) 
  5. Error: effect_plot: partial residuals work (@test-effect-plot.R#79) 
  6. Error: effect_plot works for weighted lm (@test-effect-plot.R#92) 
  7. Error: effect_plot works for svyglm (@test-effect-plot.R#136) 
  8. Error: effect_plot works for lme4 (@test-effect-plot.R#167) 
  9. Error: effect_plot handles offsets (@test-effect-plot.R#207) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted