Running ‘testthat.R’ [38s/51s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library("testthat")
  > library("plotly")
  Loading required package: ggplot2
  
  Attaching package: 'plotly'
  
  The following object is masked from 'package:ggplot2':
  
      last_plot
  
  The following object is masked from 'package:stats':
  
      filter
  
  The following object is masked from 'package:graphics':
  
      layout
  
  > library("RSclient")
  > 
  > # report any differences in plot (list) hashes if this is a Travis pull request
  > report_diffs <- grepl("^[0-9]+$", Sys.getenv("TRAVIS_PULL_REQUEST"))
  > # build a ggplot2 comparison table?
  > build_table <- Sys.getenv("PLOTLY_TABLE") == "TRUE"
  > 
  > # stuff that should be done once (not everytime save_outputs() is called)
  > if (report_diffs || build_table) {
  +   message("Spinning up an independent R session with plotly's master branch installed")
  +   Rserve::Rserve(args = "--vanilla --RS-enable-remote")
  +   conn <- RSconnect()
  +   # ensure the seed is the same for randomized tests
  +   set.seed(1)
  +   RSeval(conn, "set.seed(1)")
  +   # we don't make assumptions about ggplot2 versioning,
  +   # but it is _strongly_ recommended to use the CRAN version (of ggplot2)
  +   RSeval(conn, "devtools::install_github('ropensci/plotly')")
  +   RSeval(conn, "library(plotly)")
  +   if (report_diffs) {
  +     # hash of the version being tested
  +     this_hash <- substr(Sys.getenv("TRAVIS_COMMIT"), 1, 7)
  +     # hash of version to compare with (master)
  +     master_hash <- RSeval(conn, "packageDescription('plotly')$GithubSHA1")
  +     master_hash <- substr(master_hash, 1, 7)
  +     # plotly-test-table repo hosts the diff pages & keeps track of previous versions
  +     table_dir <- normalizePath("../../plotly-test-table", mustWork = T)
  +     # Make sure we have appropriate versions of plotlyjs
  +     # (see plotly-test-table/template/template/index.html)
  +     file.copy(
  +       file.path("..", "inst", "htmlwidgets", "lib", "plotlyjs", "plotly-latest.min.js"),
  +       file.path(table_dir, "template", "New.min.js"),
  +       overwrite = TRUE
  +     )
  +     download.file(
  +       "https://raw.githubusercontent.com/ropensci/plotly/master/inst/htmlwidgets/lib/plotlyjs/plotly-latest.min.js", 
  +       file.path(table_dir, "template", "Old.min.js"),
  +       method = "curl"
  +     )
  +     # directory for placing test differences
  +     this_dir <- file.path(table_dir, this_hash)
  +     if (dir.exists(this_dir)) {
  +       message("Tests were already run on this commit. Nuking the old results...")
  +       unlink(this_dir, recursive = T)
  +     }
  +     master_dir <- file.path(table_dir, master_hash)
  +     # csv file that tracks plot hashes
  +     hash_file <- file.path(table_dir, "hashes.csv")
  +     if (!file.exists(hash_file)) {
  +       file.create(hash_file)
  +       cat("commit,test,hash\n", file = hash_file, append = T)
  +     }
  +     hash_info <- utils::read.csv(hash_file)
  +     master_info <- hash_info[hash_info$commit %in% master_hash, ]
  +   }
  + }
  > 
  > # Some tests make plot.ly HTTP requests and require a valid user account
  > # (see test-plotly-filename.R). For security reasons, these tests should be 
  > # skipped on pull requests (the .travis.yml file uses encrypted credentials
  > # & encrypted environment vars cannot be accessed on pull request builds)
  > skip_if_not_master <- function() {
  +   is_pr <- grepl("^[0-9]+$", Sys.getenv("TRAVIS_PULL_REQUEST"))
  +   is_r_release <- Sys.getenv("TRAVIS_R_VERSION_STRING", "release") == "release"
  +   if (!is_pr && is_r_release) return(invisible(TRUE))
  +   skip("plot.ly API calls are only tested on the master build on r-release")
  + }
  > 
  > # This function is called within testthat/test-*.R files.
  > # It takes a ggplot or plotly object as input, and it returns a figure
  > # object (aka the data behind the plot).
  > save_outputs <- function(gg, name) {
  +   print(paste("Running test:", name))
  +   p <- plotly_build(gg)$x[c("data", "layout")]
  +   has_diff <- if (report_diffs) {
  +     # save a hash of the R object
  +     plot_hash <- digest::digest(p)
  +     info <- paste(this_hash, name, plot_hash, sep = ",")
  +     cat(paste(info, "\n"), file = hash_file, append = T)
  +     test_info <- master_info[master_info$test %in% name, ]
  +     # is the plot hash different from master?
  +     !isTRUE(plot_hash == test_info$hash)
  +   } else FALSE
  +   if (has_diff || build_table) {
  +     RSassign(conn, gg)
  +     pm <- RSeval(conn, "tryCatch(plotly::plotly_build(gg)$x[c('data', 'layout')], error = function(e) e$message)")
  +     if (build_table) {
  +       # save pngs of ggplot
  +       filename <- paste0(gsub("\\s+", "-", name), ".png")
  +       ggFile <- paste("ggplot", filename, sep = "-")
  +       res <- tryCatch(ggsave(ggFile, gg), 
  +                       error = function(e) {
  +                         err <- ggplot() + 
  +                           annotate('text', label = paste('Error:', e$message), 
  +                                    x = 1, y = 1, color = 'red')
  +                         ggsave(ggFile, err, width = 3, height = 2, units = 'in')
  +                       })
  +       img <- function(x, f) {
  +         tryCatch(plotly_IMAGE(x, out_file = f, width = 300, height = 400),
  +                  error = function(e) {
  +                    err <- ggplot() + 
  +                      annotate('text', label = paste('Error:', e$message), 
  +                               x = 1, y = 1, color = 'red')
  +                    # TODO: convert pixels to inches?
  +                    ggsave(plotlyFile, err, width = 3, height = 2, units = 'in')
  +                  })
  +       }
  +       # save _this_ plotly version
  +       plotlyFile <- paste("plotly", this_hash, filename, sep = "-")
  +       res <- img(p, plotlyFile)
  +       # save _master_ plotly version
  +       plotlyFile <- paste("plotly", "master", filename, sep = "-")
  +       RSassign(conn, plotlyFile, "plotlyFile")
  +       RSassign(conn, img, "img")
  +       res <- RSeval(conn, "img(p, plotlyFile)")
  +     }
  +     # it could be that the hash didn't exist, so make sure they're different
  +     # before build a diff page
  +     if (plot_hash != digest::digest(pm)) {
  +       test_dir <- file.path(this_dir, gsub("\\s+", "-", name))
  +       if (dir.exists(test_dir)) stop(shQuote(name), " has already been used to save_outputs() in another test.")
  +       dir.create(test_dir, recursive = T)
  +       # copy over diffing template
  +       file.copy(
  +         dir(file.path(table_dir, "template", "template"), full.names = TRUE), test_dir
  +       )
  +       # overwrite the default JSON
  +       writeLines(
  +         paste("New =", plotly:::to_JSON(p)), 
  +         file.path(test_dir, "New.json")
  +       )
  +       writeLines(
  +         paste("Old =", plotly:::to_JSON(pm)), 
  +         file.path(test_dir, "Old.json")
  +       )
  +     }
  +   }
  +   p
  + }
  > 
  > # use me just like testthat::test_check()
  > test_run <- function(...) {
  +   # shut down the other R session on exit
  +   if (report_diffs || build_table) {
  +     on.exit(RSshutdown(conn))
  +     on.exit(RSclose(conn), add = TRUE)
  +   }
  +   test_check(...)
  + }
  > 
  > test_run("plotly")
  ── 1. Error: SharedData produces key/set in ggplotly (@test-animate-highlight.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-animate-highlight.R:18
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 2. Error: When key is equivalent to group, produce simple keys (@test-animate
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(gg) at testthat/test-animate-highlight.R:91
  2: plotly_build.gg(gg)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 3. Error: When key is nested within group, produce simple key (@test-animate-
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(gg) at testthat/test-animate-highlight.R:121
  2: plotly_build.gg(gg)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 4. Error: Key structure is passed along to frame data (@test-animate-highligh
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: suppressWarnings(plotly_build(p)$x) at testthat/test-animate-highlight.R:149
  2: withCallingHandlers(expr, warning = function(w) invokeRestart("muffleWarning"))
  3: plotly_build(p)
  4: plotly_build.gg(p)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 5. Error: animation frames are boxed up correctly (@test-animate-highlight.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-animate-highlight.R:345
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 6. Error: sf works with crosstalk (@test-animate-highlight.R#382)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p, tooltip = "text") at testthat/test-animate-highlight.R:382
  2: ggplotly.ggplot(p, tooltip = "text")
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-flevels"
  ── 7. Error: factor levels determine tick order (@test-cookbook-axes.R#28)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.flevels, 1, "flevels") at testthat/test-cookbook-axes.R:28
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-ylim.hide"
  ── 8. Error: ylim hides points (@test-cookbook-axes.R#36)  ─────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.ylim.hide, 1, "ylim.hide") at testthat/test-cookbook-axes.R:36
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scale.hide"
  ── 9. Error: scale_y(limits) hides points (@test-cookbook-axes.R#41)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.scale.hide, 1, "scale.hide") at testthat/test-cookbook-axes.R:41
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-coord-ylim"
  ── 10. Error: Using coord_cartesian zooms into the area (@test-cookbook-axes.R#4
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.coord, 1, "coord-ylim") at testthat/test-cookbook-axes.R:49
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-linear-axes"
  ── 11. Error: A scatterplot with regular (linear) axis scaling (@test-cookbook-a
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp, 1, "linear-axes") at testthat/test-cookbook-axes.R:64
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-log2-scale"
  ── 12. Error: log2 scaling of the y axis (with visually-equal spacing) (@test-co
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp.log2.scale, 1, "log2-scale") at testthat/test-cookbook-axes.R:71
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-log2-coord"
  ── 13. Error: log2 coordinate transformation with visually-diminishing spacing (
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp.log2.coord, 1, "log2-coord") at testthat/test-cookbook-axes.R:77
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-log2-labels"
  ── 14. Error: log2 transform with labels (@test-cookbook-axes.R#86)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp.labels, 1, "log2-labels") at testthat/test-cookbook-axes.R:86
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scale_y_log10"
  ── 15. Error: scale_y_log10 (@test-cookbook-axes.R#92)  ────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp.log10, 1, "scale_y_log10") at testthat/test-cookbook-axes.R:92
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scale_y_log10-labels"
  ── 16. Error: log10 with exponents on tick labels (@test-cookbook-axes.R#100)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp.log10.labels, 1, "scale_y_log10-labels") at testthat/test-cookbook-axes.R:100
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-no-x-title"
  ── 17. Error: coord_fixed(ratio) (@test-cookbook-axes.R#108)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(no.x.title, 1, "no-x-title") at testthat/test-cookbook-axes.R:108
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scale-name"
  ── 18. Error: scale(name) (@test-cookbook-axes.R#119)  ─────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.scale.name, 1, "scale-name") at testthat/test-cookbook-axes.R:119
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-fonts"
  ── 19. Error: element_text face, colour, size, angle, vjust, size (@test-cookboo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.fonts, 1, "fonts") at testthat/test-cookbook-axes.R:134
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-label-funs"
  ── 20. Error: In this particular case, x scale has no effect (@test-cookbook-axe
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(label.funs, 1, "label-funs") at testthat/test-cookbook-axes.R:148
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-custom-formatter"
  ── 21. Error: custom HMS formatter function (@test-cookbook-axes.R#164)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(custom.formatter, 1, "custom-formatter") at testthat/test-cookbook-axes.R:164
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-blank-minor-major"
  ── 22. Error: Hide all the gridlines (@test-cookbook-axes.R#172)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(blank.minor.major, 1, "blank-minor-major") at testthat/test-cookbook-axes.R:172
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-blank-minor"
  ── 23. Error: Hide just the minor gridlines (@test-cookbook-axes.R#179)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(blank.minor, 1, "blank-minor") at testthat/test-cookbook-axes.R:179
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-blank-x"
  ── 24. Error: Hide all the horizontal gridlines (@test-cookbook-axes.R#187)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(blank.x, 1, "blank-x") at testthat/test-cookbook-axes.R:187
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-blank-y"
  ── 25. Error: Hide all the vertical gridlines (@test-cookbook-axes.R#195)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(blank.y, 1, "blank-y") at testthat/test-cookbook-axes.R:195
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-axes.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-basic-bar"
  ── 26. Error: geom_bar -> 1 trace (@test-cookbook-lines.R#27)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp, 1, "basic-bar") at testthat/test-cookbook-lines.R:27
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-basic-horizontal-line"
  ── 27. Error: bar + hline = 2 traces (@test-cookbook-lines.R#33)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(temp, 2, "basic-horizontal-line") at testthat/test-cookbook-lines.R:33
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-dashed-red-line"
  ── 28. Error: bar + red dashed hline (@test-cookbook-lines.R#39)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(temp, 2, "dashed-red-line") at testthat/test-cookbook-lines.R:39
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-error-wide"
  ── 29. Error: Draw with separate lines for each bar (@test-cookbook-lines.R#54) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.err, 2, "bar-error-wide") at testthat/test-cookbook-lines.R:54
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-error-narrow"
  ── 30. Error: Make the lines narrower (@test-cookbook-lines.R#61)  ─────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.err.narrow, 2, "bar-error-narrow") at testthat/test-cookbook-lines.R:61
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-error-diff"
  ── 31. Error: The bar graph are from df, but the lines are from df.hlines (@test
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.err.diff, 2, "bar-error-diff") at testthat/test-cookbook-lines.R:77
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-dodge-color"
  ── 32. Error: bar dodged colored -> 1 trace (@test-cookbook-lines.R#92)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp, 2, "bar-dodge-color") at testthat/test-cookbook-lines.R:92
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-dodge-color-error"
  ── 33. Error: The error bars get plotted over one another (@test-cookbook-lines.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.err, 4, "bar-dodge-color-error") at testthat/test-cookbook-lines.R:100
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-bar-dodge-color-err4"
  ── 34. Error: 4 error bars (@test-cookbook-lines.R#119)  ───────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(bp.err4, 4, "bar-dodge-color-err4") at testthat/test-cookbook-lines.R:119
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-basic"
  ── 35. Error: basic scatterplot (@test-cookbook-lines.R#148)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(sp, 2, "scatter-basic") at testthat/test-cookbook-lines.R:148
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-hline"
  ── 36. Error: Add a horizontal line (@test-cookbook-lines.R#153)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(temp, 3, "scatter-hline") at testthat/test-cookbook-lines.R:153
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-hline-vline"
  ── 37. Error: Add a red dashed vertical line (@test-cookbook-lines.R#161)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(temp, 4, "scatter-hline-vline") at testthat/test-cookbook-lines.R:161
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-facet"
  ── 38. Error: scatter facet -> 2 traces (@test-cookbook-lines.R#176)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(spf, 2, "scatter-facet") at testthat/test-cookbook-lines.R:176
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-facet-hline"
  ── 39. Error: geom_hline -> 2 more traces (@test-cookbook-lines.R#185)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(temp, 4, "scatter-facet-hline") at testthat/test-cookbook-lines.R:185
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-scatter-facet-hline-vline"
  ── 40. Error: geom_vline -> 2 more traces (@test-cookbook-lines.R#204)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(spf.vline, 6, "scatter-facet-hline-vline") at testthat/test-cookbook-lines.R:204
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-cookbook-lines.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: scatterplots-hollow"
  ── 41. Error: (unknown) (@test-cookbook-scatterplots.R#15)  ────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "scatterplots-hollow") at testthat/test-cookbook-scatterplots.R:15
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-single-abline"
  ── 42. Error: Second trace be the a-b line (@test-ggplot-abline.R#25)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "single-abline") at testthat/test-ggplot-abline.R:25
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-ggplot-abline.R:7
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: cookbook-axes-multiple-abline"
  ── 43. Error: abline aesthetics (@test-ggplot-abline.R#42)  ────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "multiple-abline") at testthat/test-ggplot-abline.R:42
  2: save_outputs(gg, paste0("cookbook-axes-", name)) at testthat/test-ggplot-abline.R:7
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 44. Error: Basic annotation_raster() example works (@test-ggplot-annotation_.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-annotation_.R:13
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 45. Error: Basic annotation_map() example works (@test-ggplot-annotation_.R#5
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-annotation_.R:51
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: area-simple"
  ── 46. Error: sanity check for geom_area (@test-ggplot-area.R#25)  ─────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(ar, 1, "simple") at testthat/test-ggplot-area.R:25
  2: save_outputs(gg, paste0("area-", name)) at testthat/test-ggplot-area.R:7
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: area-area-fillcolor"
  ── 47. Error: transparency alpha in geom_area is converted (@test-ggplot-area.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 1, "area-fillcolor") at testthat/test-ggplot-area.R:39
  2: save_outputs(gg, paste0("area-", name)) at testthat/test-ggplot-area.R:7
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: area-traces_order"
  ── 48. Error: traces are ordered correctly in geom_area (@test-ggplot-area.R#60)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 5, "traces_order") at testthat/test-ggplot-area.R:60
  2: save_outputs(gg, paste0("area-", name)) at testthat/test-ggplot-area.R:7
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-dodge"
  ── 49. Error: position_dodge() (@test-ggplot-bar.R#26)  ────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg.dodge, 2, "dodge") at testthat/test-ggplot-bar.R:26
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-stack"
  ── 50. Error: position_stack() (@test-ggplot-bar.R#39)  ────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg.stack, 2, "stack") at testthat/test-ggplot-bar.R:39
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-identity"
  ── 51. Error: position_identity() (@test-ggplot-bar.R#48)  ─────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg.identity, 2, "identity") at testthat/test-ggplot-bar.R:48
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-dates"
  ── 52. Error: dates work well with bar charts (@test-ggplot-bar.R#60)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gd, 2, "dates") at testthat/test-ggplot-bar.R:60
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-nocolor"
  ── 53. Error: Very basic bar graph (@test-ggplot-bar.R#89)  ────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 1, "nocolor") at testthat/test-ggplot-bar.R:89
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-color"
  ── 54. Error: Map the time of day to different fill colors (@test-ggplot-bar.R#9
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "color") at testthat/test-ggplot-bar.R:98
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-black-outline"
  ── 55. Error: Add a black outline (@test-ggplot-bar.R#109)  ────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "black-outline") at testthat/test-ggplot-bar.R:109
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-aes-fill-guides-color-none"
  ── 56. Error: guides(colour="none") does not affect fill legend (@test-ggplot-ba
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "aes-fill-guides-color-none") at testthat/test-ggplot-bar.R:123
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-aes-colour-guides-fill-FALSE"
  ── 57. Error: guides(fill=FALSE) does not affect colour legend (@test-ggplot-bar
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "aes-colour-guides-fill-FALSE") at testthat/test-ggplot-bar.R:131
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-position-stack"
  ── 58. Error: geom_bar() stacks counts (@test-ggplot-bar.R#145)  ───────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_bar(), 3, "position-stack") at testthat/test-ggplot-bar.R:145
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-position-fill"
  ── 59. Error: geom_bar(position = 'fill') stacks proportions (@test-ggplot-bar.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_bar(position = "fill"), 3, "position-fill") at testthat/test-ggplot-bar.R:155
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-category-names"
  ── 60. Error: Using identity with multiple y for a given x works  (@test-ggplot-
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gbar, 1, "category-names") at testthat/test-ggplot-bar.R:167
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: bar-coord-flip"
  ── 61. Error: geom_bar() + coord_flip() works (@test-ggplot-bar.R#173)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "coord-flip") at testthat/test-ggplot-bar.R:173
  2: save_outputs(gg, paste0("bar-", name)) at testthat/test-ggplot-bar.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 62. Error: geom_blank (@test-ggplot-blank.R#4)  ─────────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(qplot()) at testthat/test-ggplot-blank.R:4
  2: ggplotly.ggplot(qplot())
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: boxplot"
  ── 63. Error: geom_boxplot gives a boxplot (@test-ggplot-boxplot.R#19)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "boxplot") at testthat/test-ggplot-boxplot.R:19
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 64. Error: geom_boxplot with coord_flip (@test-ggplot-boxplot.R#31)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-boxplot.R:31
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: boxplot-datetime"
  ── 65. Error: you can make a boxplot for a distribution of datetimes (@test-ggpl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(bp, "boxplot-datetime") at testthat/test-ggplot-boxplot.R:47
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: boxplot-legends_for_fill"
  ── 66. Error: legends for boxplot (@test-ggplot-boxplot.R#60)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 3, "legends_for_fill") at testthat/test-ggplot-boxplot.R:60
  2: save_outputs(gg, paste0("boxplot-", name)) at testthat/test-ggplot-boxplot.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: boxplot-fillcolor"
  ── 67. Error: correct # of unique fillcolors (@test-ggplot-boxplot.R#81)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "boxplot-fillcolor") at testthat/test-ggplot-boxplot.R:81
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: col"
  ── 68. Error: geom_col is supported (@test-ggplot-col.R#18)  ───────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "col") at testthat/test-ggplot-col.R:18
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: contour"
  ── 69. Error: geom_contour is translated to a path (@test-ggplot-contour.R#12)  
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "contour") at testthat/test-ggplot-contour.R:12
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 70. Error: single-panel fixed coordinates (@test-ggplot-coord-fixed.R#7)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(base + coord_equal()) at testthat/test-ggplot-coord-fixed.R:7
  2: ggplotly.ggplot(base + coord_equal())
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 71. Error: multi-panel fixed coordinates (@test-ggplot-coord-fixed.R#29)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p) at testthat/test-ggplot-coord-fixed.R:29
  2: ggplotly.ggplot(p)
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 72. Error: Basic geom_crossbar() works (@test-ggplot-crossbar.R#18)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-crossbar.R:18
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 73. Error: geom_crossbar() with aesthetics (@test-ggplot-crossbar.R#33)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-crossbar.R:33
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: date-strings"
  ── 74. Error: datetimes are converted to e.g. 2013-01-02 05:00:00 (@test-ggplot-
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "date-strings") at testthat/test-ggplot-date.R:11
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: date-class-Date"
  ── 75. Error: class Date is supported (@test-ggplot-date.R#25)  ────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "date-class-Date") at testthat/test-ggplot-date.R:25
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: date-irregular-time-series"
  ── 76. Error: scale_x_date and irregular time series work (@test-ggplot-date.R#3
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(dt, "date-irregular-time-series") at testthat/test-ggplot-date.R:36
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density-simple"
  ── 77. Error: geom_density() is translated to area chart (@test-ggplot-density.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_density(), 1, "simple") at testthat/test-ggplot-density.R:19
  2: save_outputs(gg, paste0("density-", name)) at testthat/test-ggplot-density.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density-fill"
  ── 78. Error: geom_density() respects fill aesthetic (@test-ggplot-density.R#28)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "fill") at testthat/test-ggplot-density.R:28
  2: save_outputs(gg, paste0("density-", name)) at testthat/test-ggplot-density.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density-color"
  ── 79. Error: geom_density() respects colour aesthetic (@test-ggplot-density.R#4
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_density(aes(colour = factor(vs))), 2, "color") at testthat/test-ggplot-density.R:43
  2: save_outputs(gg, paste0("density-", name)) at testthat/test-ggplot-density.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density-histogram"
  ── 80. Error: geom_histogram(aes(y = ..density..)) + geom_density() works (@test
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(g, 2, "histogram") at testthat/test-ggplot-density.R:58
  2: save_outputs(gg, paste0("density-", name)) at testthat/test-ggplot-density.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density-traces_order"
  ── 81. Error: traces are ordered correctly in geom_density (@test-ggplot-density
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 3, "traces_order") at testthat/test-ggplot-density.R:70
  2: save_outputs(gg, paste0("density-", name)) at testthat/test-ggplot-density.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: density2d"
  ── 82. Error: (unknown) (@test-ggplot-density2d.R#7)  ──────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(m, "density2d") at testthat/test-ggplot-density2d.R:7
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 83. Error: ggplotly doesn't leave a new device open (@test-ggplot-device.R#5)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(ggplot(mtcars) + geom_point(aes(wt, mpg))) at testthat/test-ggplot-device.R:5
  2: ggplotly.ggplot(ggplot(mtcars) + geom_point(aes(wt, mpg)))
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 84. Error: Discrete axis maps to categorical type (@test-ggplot-dynamicTicks.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(g, dynamicTicks = "x") at testthat/test-ggplot-dynamicTicks.R:7
  2: ggplotly.ggplot(g, dynamicTicks = "x")
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 85. Error: Categorical axis reflects custom scale mapping (@test-ggplot-dynam
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(g, dynamicTicks = "x") at testthat/test-ggplot-dynamicTicks.R:36
  2: ggplotly.ggplot(g, dynamicTicks = "x")
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 86. Error: Time axis inverse transforms correctly (@test-ggplot-dynamicTicks.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(ggplot(d, aes(x, y)) + geom_line(), dynamicTicks = TRUE) at testthat/test-ggplot-dynamicTicks.R:71
  2: ggplotly.ggplot(ggplot(d, aes(x, y)) + geom_line(), dynamicTicks = TRUE)
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 87. Error: Inverse maps colorbar data (@test-ggplot-dynamicTicks.R#100)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p, dynamicTicks = TRUE) at testthat/test-ggplot-dynamicTicks.R:100
  2: ggplotly.ggplot(p, dynamicTicks = TRUE)
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: errorbar-horizontal"
  ── 88. Error: geom_errorbarh gives horizontal errorbars (@test-ggplot-errorbar-h
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "errorbar-horizontal") at testthat/test-ggplot-errorbar-horizontal.R:15
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: errorbar"
  ── 89. Error: geom_errorbar gives errorbars (@test-ggplot-errorbar.R#15)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "errorbar") at testthat/test-ggplot-errorbar.R:15
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: errorbar-unique-groups"
  ── 90. Error: geom_errorbar boxes an array of length 1 (@test-ggplot-errorbar.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "errorbar-unique-groups") at testthat/test-ggplot-errorbar.R:37
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: barley"
  ── 91. Error: 6 facets becomes 6 panels (@test-ggplot-facets.R#20)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "barley") at testthat/test-ggplot-facets.R:20
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: 3-panels"
  ── 92. Error: 3 facets becomes 3 panels (@test-ggplot-facets.R#40)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "3-panels") at testthat/test-ggplot-facets.R:40
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_wrap_free"
  ── 93. Error: facet_wrap(..., scales = 'free') creates interior scales (@test-gg
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(free_both, "facet_wrap_free") at testthat/test-ggplot-facets.R:60
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_grid_free"
  ── 94. Error: facet_grid(..., scales = 'free') doesnt create interior scales. (@
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(free_both, "facet_grid_free") at testthat/test-ggplot-facets.R:77
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_wrap_free_mult"
  ── 95. Error: facet_wrap(..., scales = 'free') can handle multiple traces on eac
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "facet_wrap_free_mult") at testthat/test-ggplot-facets.R:97
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_wrap"
  ── 96. Error: facet_wrap() doesn't create interior scales (@test-ggplot-facets.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "facet_wrap") at testthat/test-ggplot-facets.R:108
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_wrap-labeller"
  ── 97. Error: facet_wrap translates simple labeller function (@test-ggplot-facet
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "facet_wrap-labeller") at testthat/test-ggplot-facets.R:118
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_grid-labeller"
  ── 98. Error: facet_grid translates simple labeller function (@test-ggplot-facet
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "facet_grid-labeller") at testthat/test-ggplot-facets.R:128
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: facet_wrap-free_y"
  ── 99. Error: when y scales are free, x-axes are still anchored on exterior (@te
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "facet_wrap-free_y") at testthat/test-ggplot-facets.R:140
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 100. Error: ggplotly returns original data with special attributes (@test-ggp
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p) %>% plotly_data() at testthat/test-ggplot-ggplotly.R:7
  2: eval(lhs, parent, parent)
  3: eval(lhs, parent, parent)
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 101. Error: can filter data returned by ggplotly (@test-ggplot-ggplotly.R#13)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p) %>% filter(city == "Houston") %>% plotly_data() at testthat/test-ggplot-ggplotly.R:13
  2: eval(lhs, parent, parent)
  3: eval(lhs, parent, parent)
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 102. Error: can add traces with original _and_ scaled data (@test-ggplot-ggpl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p) %>% add_lines() %>% plotly_build() at testthat/test-ggplot-ggplotly.R:19
  2: eval(lhs, parent, parent)
  3: eval(lhs, parent, parent)
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 103. Error: can access ggplot data in layout() (@test-ggplot-ggplotly.R#29)  
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p) %>% layout(title = ~range(date)) at testthat/test-ggplot-ggplotly.R:29
  2: eval(lhs, parent, parent)
  3: eval(lhs, parent, parent)
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: heatmap"
  ── 104. Error: geom_tile is translated to type=heatmap (@test-ggplot-heatmap.R#2
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(hm, "heatmap") at testthat/test-ggplot-heatmap.R:20
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: heatmap-midpoint"
  ── 105. Error: geom_tile() scale_fill_gradient2() (@test-ggplot-heatmap.R#45)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "heatmap-midpoint") at testthat/test-ggplot-heatmap.R:45
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: heatmap-discrete"
  ── 106. Error: geom_tile() with discrete x/y (@test-ggplot-heatmap.R#60)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "heatmap-discrete") at testthat/test-ggplot-heatmap.R:60
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hex-basic"
  ── 107. Error: geom_hex (@test-ggplot-hex.R#7)  ────────────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "hex-basic") at testthat/test-ggplot-hex.R:7
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hex-bins"
  ── 108. Error: geom_hex with bins (@test-ggplot-hex.R#14)  ─────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "hex-bins") at testthat/test-ggplot-hex.R:14
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hex-binwidth"
  ── 109. Error: geom_hex with binwidth (@test-ggplot-hex.R#20)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "hex-binwidth") at testthat/test-ggplot-hex.R:20
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-counts"
  ── 110. Error: geom_histogram() is a bar chart of counts with no bargap (@test-g
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_histogram(), 1, "counts") at testthat/test-ggplot-histogram.R:18
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-density"
  ── 111. Error: geom_histogram(aes(y = ..density..)) displays a density (@test-gg
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_histogram(aes(y = ..density..)), 1, "density") at testthat/test-ggplot-histogram.R:26
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fill"
  ── 112. Error: geom_histogram(aes(fill = ..count..)) works (@test-ggplot-histogr
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(base + geom_histogram(aes(fill = ..count..)), 6, "fill") at testthat/test-ggplot-histogram.R:38
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fixed-fill-color"
  ── 113. Error: Histogram with fixed colour/fill works (@test-ggplot-histogram.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 1, "fixed-fill-color") at testthat/test-ggplot-histogram.R:50
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-density-binwidth"
  ── 114. Error: Specify histogram binwidth (@test-ggplot-histogram.R#58)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 1, "density-binwidth") at testthat/test-ggplot-histogram.R:58
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fill-factor"
  ── 115. Error: geom_histogram(aes(fill = factor(...))) is a stacked by default (
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "fill-factor") at testthat/test-ggplot-histogram.R:66
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fill-factor-identity"
  ── 116. Error: geom_histogram(aes(fill = factor(...))) respects position_identit
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "fill-factor-identity") at testthat/test-ggplot-histogram.R:74
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fill-factor-dodge"
  ── 117. Error: geom_histogram(aes(fill = factor(...))) respects position_dodge()
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "fill-factor-dodge") at testthat/test-ggplot-histogram.R:82
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-fill-factor-facets"
  ── 118. Error: geom_histogram() with facets (@test-ggplot-histogram.R#89)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 4, "fill-factor-facets") at testthat/test-ggplot-histogram.R:89
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-vline"
  ── 119. Error: vline overlaid histogram (@test-ggplot-histogram.R#101)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "vline") at testthat/test-ggplot-histogram.R:101
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-dates"
  ── 120. Error: dates work well with histograms (@test-ggplot-histogram.R#116)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(hist, 1, "dates") at testthat/test-ggplot-histogram.R:116
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-POSIXt-bins"
  ── 121. Error: datetime binning for class POSIXt works in histograms (@test-ggpl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(histP, 1, "POSIXt-bins") at testthat/test-ggplot-histogram.R:224
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: histogram-Date-bins"
  ── 122. Error: datetime binning for class Date works in histograms (@test-ggplot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(histD, 1, "Date-bins") at testthat/test-ggplot-histogram.R:231
  2: save_outputs(gg, paste0("histogram-", name)) at testthat/test-ggplot-histogram.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hline"
  ── 123. Error: second trace be the hline (@test-ggplot-hline.R#12)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "hline") at testthat/test-ggplot-hline.R:12
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hline-multiple"
  ── 124. Error: vector yintercept results in multiple horizontal lines (@test-ggp
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "hline-multiple") at testthat/test-ggplot-hline.R:25
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hline-factor"
  ── 125. Error: hline can be drawn over range of factors (@test-ggplot-hline.R#46
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "hline-factor") at testthat/test-ggplot-hline.R:46
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 126. Error: hline/vline/abline split on linetype/colour/size (@test-ggplot-hl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(gg) at testthat/test-ggplot-hline.R:61
  2: plotly_build.gg(gg)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: jitter-basic"
  ── 127. Error: geom_jitter is working (@test-ggplot-jitter.R#20)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "basic") at testthat/test-ggplot-jitter.R:20
  2: save_outputs(gg, paste0("jitter-", name)) at testthat/test-ggplot-jitter.R:6
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: labels-ggtitle"
  ── 128. Error: ggtitle is translated correctly (@test-ggplot-labels.R#7)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "labels-ggtitle") at testthat/test-ggplot-labels.R:7
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: labels-ylab"
  ── 129. Error: ylab is translated correctly (@test-ggplot-labels.R#15)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "labels-ylab") at testthat/test-ggplot-labels.R:15
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: labels-angles"
  ── 130. Error: angled ticks are translated correctly (@test-ggplot-labels.R#34) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "labels-angles") at testthat/test-ggplot-labels.R:34
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 131. Error: xaxis/yaxis automargin defaults to TRUE (@test-ggplot-labels.R#40
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-labels.R:40
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: scatter_legend"
  ── 132. Error: Discrete colour and shape get merged into one legend (@test-ggplo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "scatter_legend") at testthat/test-ggplot-legend.R:19
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: legend-hide"
  ── 133. Error: legend vanishes when theme(legend.position = 'none'') (@test-ggpl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p + theme(legend.position = "none"), 5, "hide") at testthat/test-ggplot-legend.R:39
  2: save_outputs(gg, paste0("legend-", name)) at testthat/test-ggplot-legend.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: legend-very-long-legend-items"
  ── 134. Error: very long legend items (@test-ggplot-legend.R#72)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p_long_items, 3, "very-long-legend-items") at testthat/test-ggplot-legend.R:72
  2: save_outputs(gg, paste0("legend-", name)) at testthat/test-ggplot-legend.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: legend-one-entry"
  ── 135. Error: legend is created with discrete mapping regardless of unique valu
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "one-entry") at testthat/test-ggplot-legend.R:79
  2: save_outputs(gg, paste0("legend-", name)) at testthat/test-ggplot-legend.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: legend-hide-legend"
  ── 136. Error: can hide legend (@test-ggplot-legend.R#86)  ─────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(hide_legend(p), 1, "hide-legend") at testthat/test-ggplot-legend.R:86
  2: save_outputs(gg, paste0("legend-", name)) at testthat/test-ggplot-legend.R:5
  3: plotly_build(gg)
  4: hide_legend(p)
  5: plotly_build(p)
  6: plotly_build.gg(p)
  7: plotly_build(ggplotly(p))
  8: ggplotly(p)
  9: ggplotly.ggplot(p)
  10: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  11: unitConvert(theme$plot.margin, "pixels")
  12: grid::convertHeight(u, "npc")
  13: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  14: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: legend-many legend items"
  ── 137. Error: many legend items (@test-ggplot-legend.R#95)  ───────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, length(unique(midwest$category)), "many legend items") at testthat/test-ggplot-legend.R:95
  2: save_outputs(gg, paste0("legend-", name)) at testthat/test-ggplot-legend.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: linetype-types"
  ── 138. Error: 6 different automatic lty converted to plotly's 6 types (@test-gg
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "linetype-types") at testthat/test-ggplot-lines.R:14
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: linetype-colors"
  ── 139. Error: different colored lines become different colored traces (@test-gg
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "linetype-colors") at testthat/test-ggplot-lines.R:33
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 140. Error: Translates both dates and datetimes (with dynamic ticks) correctl
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(ggplotly(p, dynamicTicks = TRUE)) at testthat/test-ggplot-lines.R:60
  2: ggplotly(p, dynamicTicks = TRUE)
  3: ggplotly.ggplot(p, dynamicTicks = TRUE)
  4: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  5: unitConvert(theme$plot.margin, "pixels")
  6: grid::convertHeight(u, "npc")
  7: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  8: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 141. Error: geom_linerange() without a y aesthetic translates to a path (@tes
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-lines.R:99
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: map-facet"
  ── 142. Error: basic geom_map works (@test-ggplot-map.R#13)  ───────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "map-facet") at testthat/test-ggplot-map.R:13
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: path-lines-diff-from-paths"
  ── 143. Error: lines are different from paths (@test-ggplot-path.R#9)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "path-lines-diff-from-paths") at testthat/test-ggplot-path.R:9
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: path-colors"
  ── 144. Error: paths with different colors become different traces (@test-ggplot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "path-colors") at testthat/test-ggplot-path.R:23
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: path-colored-groups-stay-together"
  ── 145. Error: paths with the same color but different groups stay together (@te
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "path-colored-groups-stay-together") at testthat/test-ggplot-path.R:49
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: path-line-symbols"
  ── 146. Error: lines & points are merged into markers+lines traces (@test-ggplot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "path-line-symbols") at testthat/test-ggplot-path.R:69
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: point-size-alpha"
  ── 147. Error: geom_point size & alpha translate to a single trace (@test-ggplot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "point-size-alpha") at testthat/test-ggplot-point.R:18
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: open-shapes"
  ── 148. Error: marker color is non-transparent for open shapes (@test-ggplot-poi
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "open-shapes") at testthat/test-ggplot-point.R:27
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: all-shapes"
  ── 149. Error: marker color inherits from fill, when appropriate (@test-ggplot-p
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "all-shapes") at testthat/test-ggplot-point.R:42
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: point-size-alpha2"
  ── 150. Error: can plot on sub-second time scale (@test-ggplot-point.R#57)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(g, "point-size-alpha2") at testthat/test-ggplot-point.R:57
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: point-flip"
  ── 151. Error: can flip axes (@test-ggplot-point.R#69)  ────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "point-flip") at testthat/test-ggplot-point.R:69
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-black"
  ── 152. Error: polygons with different hovertext must be different traces  (@tes
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "black") at testthat/test-ggplot-polygons.R:24
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 153. Error: polygons with identical fill and hovertext generate one trace (@t
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(ggplotly(gg, tooltip = NULL)) at testthat/test-ggplot-polygons.R:36
  2: ggplotly(gg, tooltip = NULL)
  3: ggplotly.ggplot(gg, tooltip = NULL)
  4: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  5: unitConvert(theme$plot.margin, "pixels")
  6: grid::convertHeight(u, "npc")
  7: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  8: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-aes-color"
  ── 154. Error: polygons with different color become separate traces (@test-ggplo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "aes-color") at testthat/test-ggplot-polygons.R:51
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-aes-fill"
  ── 155. Error: geom_polygon(aes(fill)) -> fillcolor + line$color transparent (@t
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "aes-fill") at testthat/test-ggplot-polygons.R:70
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-color-aes-fill"
  ── 156. Error: geom_polygon(aes(fill), color) -> line$color (@test-ggplot-polygo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "color-aes-fill") at testthat/test-ggplot-polygons.R:88
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-color-fill-aes-linetype"
  ── 157. Error: geom_polygon(aes(linetype), fill, color) (@test-ggplot-polygons.R
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "color-fill-aes-linetype") at testthat/test-ggplot-polygons.R:107
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-color-fill-aes-size"
  ── 158. Error: geom_polygon(aes(size), fill, colour) (@test-ggplot-polygons.R#12
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 2, "color-fill-aes-size") at testthat/test-ggplot-polygons.R:127
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygons-canada-borders"
  ── 159. Error: borders become one trace with NA (@test-ggplot-polygons.R#146)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "polygons-canada-borders") at testthat/test-ggplot-polygons.R:146
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-star-group"
  ── 160. Error: geom_polygon(aes(group)) -> 1 trace (@test-ggplot-polygons.R#162)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(star.group, 1, "star-group") at testthat/test-ggplot-polygons.R:162
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-star-group-color"
  ── 161. Error: geom_polygon(aes(group), color) -> 1 trace (@test-ggplot-polygons
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(star.group.color, 1, "star-group-color") at testthat/test-ggplot-polygons.R:177
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: polygon-star-fill-color"
  ── 162. Error: geom_polygon(aes(group, fill), color) -> 2 trace (@test-ggplot-po
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(star.fill.color, 2, "star-fill-color") at testthat/test-ggplot-polygons.R:193
  2: save_outputs(gg, paste0("polygon-", name)) at testthat/test-ggplot-polygons.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 163. Error: Basic geom_quantile() works (@test-ggplot-quantile.R#13)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-quantile.R:13
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 164. Error: Can specify gpar() in geom_quantile() (@test-ggplot-quantile.R#38
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-quantile.R:38
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-black"
  ── 165. Error: geom_rect becomes 1 trace with mode="lines" fill="toself" (@test-
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg, 1, "black") at testthat/test-ggplot-rect.R:24
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-black4"
  ── 166. Error: trace contains NA back to 1st rect (@test-ggplot-rect.R#43)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg4, 1, "black4") at testthat/test-ggplot-rect.R:43
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-color"
  ── 167. Error: rect color (@test-ggplot-rect.R#64)  ────────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(rect.color, 2, "color") at testthat/test-ggplot-rect.R:64
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-fill"
  ── 168. Error: rect color (@test-ggplot-rect.R#87)  ────────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(rect.fill, 2, "fill") at testthat/test-ggplot-rect.R:87
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-fill-color"
  ── 169. Error: rect aes(fill) with constant color (@test-ggplot-rect.R#111)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(rect.fill.color, 2, "fill-color") at testthat/test-ggplot-rect.R:111
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: rect-fill-hex-alpha"
  ── 170. Error: Specifying alpha in hex color code works (@test-ggplot-rect.R#138
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "fill-hex-alpha") at testthat/test-ggplot-rect.R:138
  2: save_outputs(gg, paste0("rect-", name)) at testthat/test-ggplot-rect.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 171. Error: ggplotly shouldn't populate layout.[width/height] by default (@te
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(qplot(1:10)) at testthat/test-ggplot-resize.R:4
  2: ggplotly.ggplot(qplot(1:10))
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ribbon-alpha"
  ── 172. Error: geom_ribbon() creates 1 trace & respects alpha transparency (@tes
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p1, 1, "alpha") at testthat/test-ggplot-ribbon.R:24
  2: save_outputs(gg, paste0("ribbon-", name)) at testthat/test-ggplot-ribbon.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ribbon-group"
  ── 173. Error: geom_ribbon() with group aesthetic produces 1 trace (@test-ggplot
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p2, 1, "group") at testthat/test-ggplot-ribbon.R:33
  2: save_outputs(gg, paste0("ribbon-", name)) at testthat/test-ggplot-ribbon.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ribbon-colour"
  ── 174. Error: geom_ribbon() with colour aesthetic produces multiple traces (@te
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p3, 10, "colour") at testthat/test-ggplot-ribbon.R:41
  2: save_outputs(gg, paste0("ribbon-", name)) at testthat/test-ggplot-ribbon.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ribbon-fill"
  ── 175. Error: geom_ribbon() with fill aesthetic produces multiple traces (@test
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p4, 10, "fill") at testthat/test-ggplot-ribbon.R:49
  2: save_outputs(gg, paste0("ribbon-", name)) at testthat/test-ggplot-ribbon.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 176. Error: Basic geom_rug() works (@test-ggplot-rug.R#10)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-rug.R:10
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 177. Error: geom_rug() with facets (@test-ggplot-rug.R#35)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-rug.R:35
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 178. Error: geom_rug() with graphical parameters (@test-ggplot-rug.R#48)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-rug.R:48
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: segment"
  ── 179. Error: segments become one path (@test-ggplot-segment.R#12)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "segment") at testthat/test-ggplot-segment.R:12
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: segment-multiple-non-numeric"
  ── 180. Error: with non-numeric data, we can have more than one segment (@test-g
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "segment-multiple-non-numeric") at testthat/test-ggplot-segment.R:41
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf"
  ── 181. Error: geom_sf() basic polygons. (@test-ggplot-sf.R#10)  ───────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf") at testthat/test-ggplot-sf.R:10
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf-geom-collection"
  ── 182. Error: geom_sf() geometry collection. (@test-ggplot-sf.R#32)  ──────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf-geom-collection") at testthat/test-ggplot-sf.R:32
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf-fill-text"
  ── 183. Error: geom_sf() polygons with fill/text. (@test-ggplot-sf.R#52)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf-fill-text") at testthat/test-ggplot-sf.R:52
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf-points"
  ── 184. Error: geom_sf() with basic polygons and points. (@test-ggplot-sf.R#73) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf-points") at testthat/test-ggplot-sf.R:73
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf-aspect"
  ── 185. Error: sf aspect ratio is correct (@test-ggplot-sf.R#87)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf-aspect") at testthat/test-ggplot-sf.R:87
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: sf-theme-map"
  ── 186. Error: works with a blank theme (@test-ggplot-sf.R#99)  ────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "sf-theme-map") at testthat/test-ggplot-sf.R:99
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: size-is-a-vector"
  ── 187. Error: size is a vector if it is specified (@test-ggplot-size.R#6)  ────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(iplot, "size-is-a-vector") at testthat/test-ggplot-size.R:6
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: size-global-scaling"
  ── 188. Error: global scaling works for sizes over different traces (@test-ggplo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "size-global-scaling") at testthat/test-ggplot-size.R:24
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-basic"
  ── 189. Error: geom_point() + geom_smooth() produces 3 traces (@test-ggplot-smoo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 3, "basic") at testthat/test-ggplot-smooth.R:18
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-se-false"
  ── 190. Error: geom_point() + geom_smooth(se = FALSE) produces 2 traces (@test-g
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p2, 2, "se-false") at testthat/test-ggplot-smooth.R:25
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-group"
  ── 191. Error: geom_smooth() respects group aesthetic (@test-ggplot-smooth.R#32)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p3, 3, "group") at testthat/test-ggplot-smooth.R:32
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-colour"
  ── 192. Error: geom_smooth() respects colour aesthetic (@test-ggplot-smooth.R#39
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p4, 15, "colour") at testthat/test-ggplot-smooth.R:39
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-fill2"
  ── 193. Error: geom_smooth() respects fill aesthetic (@test-ggplot-smooth.R#54) 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p7, 11, "fill2") at testthat/test-ggplot-smooth.R:54
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: smooth-facet"
  ── 194. Error: geom_smooth() works with facets (@test-ggplot-smooth.R#63)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p8, 15, "facet") at testthat/test-ggplot-smooth.R:63
  2: save_outputs(gg, paste0("smooth-", name)) at testthat/test-ggplot-smooth.R:5
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 195. Error: Basic geom_spoke() (@test-ggplot-spoke.R#12)  ───────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-spoke.R:12
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 196. Error: Basic geom_spoke() with color (@test-ggplot-spoke.R#35)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly_build(p) at testthat/test-ggplot-spoke.R:35
  2: plotly_build.gg(p)
  3: plotly_build(ggplotly(p))
  4: ggplotly(p)
  5: ggplotly.ggplot(p)
  6: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  7: unitConvert(theme$plot.margin, "pixels")
  8: grid::convertHeight(u, "npc")
  9: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  10: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: step-gg.hv"
  ── 197. Error: direction hv is translated to shape=hv (@test-ggplot-step.R#12)  
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg.hv, "step-gg.hv") at testthat/test-ggplot-step.R:12
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: step-gg.vh"
  ── 198. Error: direction vh is translated to shape=vh (@test-ggplot-step.R#19)  
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg.vh, "step-gg.vh") at testthat/test-ggplot-step.R:19
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: step-gg.hvh"
  ── 199. Error: direction hvh is translated to shape=hvh (@test-ggplot-step.R#26)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg.hvh, "step-gg.hvh") at testthat/test-ggplot-step.R:26
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: step-gg.vhv"
  ── 200. Error: direction vhv is translated to shape=vhv (@test-ggplot-step.R#33)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg.vhv, "step-gg.vhv") at testthat/test-ggplot-step.R:33
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: text"
  ── 201. Error: (unknown) (@test-ggplot-text.R#5)  ──────────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "text") at testthat/test-ggplot-text.R:5
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-background"
  ── 202. Error: background translated correctly (@test-ggplot-theme.R#11)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "theme-background") at testthat/test-ggplot-theme.R:11
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-ticks-and-grids"
  ── 203. Error: grid/ticks translated correctly (@test-ggplot-theme.R#21)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "theme-ticks-and-grids") at testthat/test-ggplot-theme.R:21
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-ticks-default"
  ── 204. Error: show ticks as 'outside' by default (@test-ggplot-theme.R#31)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "theme-ticks-default") at testthat/test-ggplot-theme.R:31
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-zeroline-default"
  ── 205. Error: do not show zeroline by default (@test-ggplot-theme.R#40)  ──────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "theme-zeroline-default") at testthat/test-ggplot-theme.R:40
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-marker-default"
  ── 206. Error: marker default shape is a circle (@test-ggplot-theme.R#58)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "theme-marker-default") at testthat/test-ggplot-theme.R:58
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: theme-panel-border-1"
  ── 207. Error: plot panel border is translated correctly (@test-ggplot-theme.R#6
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(ggiris, "theme-panel-border-1") at testthat/test-ggplot-theme.R:67
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-boxes"
  ── 208. Error: boxes without coord_flip() (@test-ggplot-ticks.R#21)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes, 1, "boxes") at testthat/test-ggplot-ticks.R:21
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-boxes-facet-grid"
  ── 209. Error: boxes with facet_grid (@test-ggplot-ticks.R#26)  ────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(facets, 2, "boxes-facet-grid") at testthat/test-ggplot-ticks.R:26
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-boxes-scales-free"
  ── 210. Error: boxes with facet_grid(scales="free") (@test-ggplot-ticks.R#31)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(facets.scales, 2, "boxes-scales-free") at testthat/test-ggplot-ticks.R:31
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-boxes-space-free"
  ── 211. Error: boxes with facet_grid(scales="free", space="free") (@test-ggplot-
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(facets.space, 2, "boxes-space-free") at testthat/test-ggplot-ticks.R:37
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-flip"
  ── 212. Error: boxes with coord_flip() (@test-ggplot-ticks.R#43)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(flipped, 1, "flip") at testthat/test-ggplot-ticks.R:43
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-flip-grid"
  ── 213. Error: boxes with coord_flip()+facet_grid() (@test-ggplot-ticks.R#48)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(flip.facet, 2, "flip-grid") at testthat/test-ggplot-ticks.R:48
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-flip-grid-free"
  ── 214. Error: boxes with coord_flip()+facet_grid(scales="free") (@test-ggplot-t
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(flip.facet.scales, 2, "flip-grid-free") at testthat/test-ggplot-ticks.R:54
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-limits-hide"
  ── 215. Error: limits can hide data (@test-ggplot-ticks.R#59)  ─────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.limits, 1, "limits-hide") at testthat/test-ggplot-ticks.R:59
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-limits-gap"
  ── 216. Error: limits can create a gap (@test-ggplot-ticks.R#65)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.limits, 1, "limits-gap") at testthat/test-ggplot-ticks.R:65
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-breaks-nochange"
  ── 217. Error: setting breaks does not change order (@test-ggplot-ticks.R#73)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.breaks, 1, "breaks-nochange") at testthat/test-ggplot-ticks.R:73
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-breaks-more"
  ── 218. Error: more breaks is fine (@test-ggplot-ticks.R#84)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.more, 1, "breaks-more") at testthat/test-ggplot-ticks.R:84
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-breaks-less"
  ── 219. Error: less breaks is fine (@test-ggplot-ticks.R#95)  ──────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.less, 1, "breaks-less") at testthat/test-ggplot-ticks.R:95
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-scale-labels"
  ── 220. Error: scale(labels) changes trace names (@test-ggplot-ticks.R#104)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.labels, 1, "scale-labels") at testthat/test-ggplot-ticks.R:104
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-hide-ticks-lines-labels"
  ── 221. Error: hide x ticks, lines, and labels (@test-ggplot-ticks.R#114)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(no.breaks, 1, "hide-ticks-lines-labels") at testthat/test-ggplot-ticks.R:114
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-hide-ticks-labels"
  ── 222. Error: Hide X ticks and labels, but keep the gridlines (@test-ggplot-tic
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.grid, 1, "hide-ticks-labels") at testthat/test-ggplot-ticks.R:126
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-ycontinuous-ranges"
  ── 223. Error: scale_y_continuous(limits) means yaxis$ranges (@test-ggplot-ticks
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.range, 1, "ycontinuous-ranges") at testthat/test-ggplot-ticks.R:135
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-ylim-ranges"
  ── 224. Error: ylim() means yaxis$ranges (@test-ggplot-ticks.R#142)  ───────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.range, 1, "ylim-ranges") at testthat/test-ggplot-ticks.R:142
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-yreverse-ranges"
  ── 225. Error: scale_y_reverse() -> yaxis$ranges reversed (@test-ggplot-ticks.R#
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.reverse, 1, "yreverse-ranges") at testthat/test-ggplot-ticks.R:149
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-yreverse-limits-ranges"
  ── 226. Error: scale_y_reverse(limits) -> yaxis$ranges reversed (@test-ggplot-ti
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.reverse, 1, "yreverse-limits-ranges") at testthat/test-ggplot-ticks.R:154
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-ylim-reversed-ranges"
  ── 227. Error: ylim(reversed) -> yaxis$ranges reversed (@test-ggplot-ticks.R#159
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.reverse, 1, "ylim-reversed-ranges") at testthat/test-ggplot-ticks.R:159
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-evenly-spaced-ticks"
  ── 228. Error: Set the X tick mark locations (@test-ggplot-ticks.R#166)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(boxes.ticks, 1, "evenly-spaced-ticks") at testthat/test-ggplot-ticks.R:166
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-uneven"
  ── 229. Error: The breaks can be spaced unevenly (@test-ggplot-ticks.R#174)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(no.breaks, 1, "uneven") at testthat/test-ggplot-ticks.R:174
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ticks-line-breaks"
  ── 230. Error: R line breaks are translated to HTML line breaks (@test-ggplot-ti
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(p, 1, "line-breaks") at testthat/test-ggplot-ticks.R:187
  2: save_outputs(gg, paste0("ticks-", name)) at testthat/test-ggplot-ticks.R:9
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: tooltip-datetime"
  ── 231. Error: datetimes are displayed in tooltip properly (@test-ggplot-tooltip
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "tooltip-datetime") at testthat/test-ggplot-tooltip.R:10
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: tooltip-date"
  ── 232. Error: dates are displayed in tooltip properly (@test-ggplot-tooltip.R#2
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "tooltip-date") at testthat/test-ggplot-tooltip.R:24
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 233. Error: tooltip argument respects ordering (@test-ggplot-tooltip.R#35)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(p, tooltip = c("density", "x")) at testthat/test-ggplot-tooltip.R:35
  2: ggplotly.ggplot(p, tooltip = c("density", "x"))
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 234. Error: can hide x values in tooltip (@test-ggplot-tooltip.R#44)  ───────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: ggplotly(gg2, tooltip = "y") at testthat/test-ggplot-tooltip.R:44
  2: ggplotly.ggplot(gg2, tooltip = "y")
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: heatmap-discrete-tooltip"
  ── 235. Error: geom_tile() displays correct info in tooltip with discrete y (@te
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "heatmap-discrete-tooltip") at testthat/test-ggplot-tooltip.R:53
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: group-lines-hovertext"
  ── 236. Error: group domain is included in hovertext (@test-ggplot-tooltip.R#66)
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "group-lines-hovertext") at testthat/test-ggplot-tooltip.R:66
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 237. Error: tooltip elements are not crossed (@test-ggplot-tooltip.R#90)  ───
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: plotly::ggplotly(gplt) at testthat/test-ggplot-tooltip.R:90
  2: ggplotly.ggplot(gplt)
  3: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  4: unitConvert(theme$plot.margin, "pixels")
  5: grid::convertHeight(u, "npc")
  6: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  7: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: hovertext-display"
  ── 238. Error: Hoverinfo is only displayed if no tooltip variables are present (
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "hovertext-display") at testthat/test-ggplot-tooltip.R:115
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: violin"
  ── 239. Error: basic geom_violin works (@test-ggplot-violin.R#6)  ──────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg, "violin") at testthat/test-ggplot-violin.R:6
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: violin-aes"
  ── 240. Error: geom_violin with fill aes works (@test-ggplot-violin.R#20)  ─────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(gg2, "violin-aes") at testthat/test-ggplot-violin.R:20
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: vline"
  ── 241. Error: second trace be the vline (@test-ggplot-vline.R#11)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "vline") at testthat/test-ggplot-vline.R:11
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: vline-multiple"
  ── 242. Error: vector xintercept results in multiple vertical lines (@test-ggplo
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(p, "vline-multiple") at testthat/test-ggplot-vline.R:25
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: ylim-one-trace"
  ── 243. Error: ylim is respected for 1 trace (@test-ggplot-ylim.R#30)  ─────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: expect_traces(gg.ylim, 1, "one-trace") at testthat/test-ggplot-ylim.R:30
  2: save_outputs(gg, paste0("ylim-", name)) at testthat/test-ggplot-ylim.R:19
  3: plotly_build(gg)
  4: plotly_build.gg(gg)
  5: plotly_build(ggplotly(p))
  6: ggplotly(p)
  7: ggplotly.ggplot(p)
  8: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  9: unitConvert(theme$plot.margin, "pixels")
  10: grid::convertHeight(u, "npc")
  11: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  12: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: error-simple"
  ── 244. Error: only asymmetric error bars (@test-mean-error-bars.R#13)  ────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(error.gg, "error-simple") at testthat/test-mean-error-bars.R:13
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: error-simple-line"
  ── 245. Error: asymmetric error bars, geom_errorbar last (@test-mean-error-bars.
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(one.line.gg, "error-simple-line") at testthat/test-mean-error-bars.R:21
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: error-simple-line-point"
  ── 246. Error: asymmetric error bars, geom_errorbar first (@test-mean-error-bars
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(one.line.gg, "error-simple-line-point") at testthat/test-mean-error-bars.R:29
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: error-simple-line-point-crazy"
  ── 247. Error: different colors for error bars, points, and lines (@test-mean-er
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(one.line.gg, "error-simple-line-point-crazy") at testthat/test-mean-error-bars.R:37
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: error-rect-alpha"
  ── 248. Error: error bars respect trace ordering (@test-mean-error-bars.R#55)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: save_outputs(fig1, "error-rect-alpha") at testthat/test-mean-error-bars.R:55
  2: plotly_build(gg)
  3: plotly_build.gg(gg)
  4: plotly_build(ggplotly(p))
  5: ggplotly(p)
  6: ggplotly.ggplot(p)
  7: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  8: unitConvert(theme$plot.margin, "pixels")
  9: grid::convertHeight(u, "npc")
  10: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  11: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: plotly-color-scatterplot-color-factor"
  [1] "Running test: plotly-color-scatterplot-color-factor-custom"
  [1] "Running test: plotly-color-scatterplot-color-factor-custom2"
  [1] "Running test: plotly-color-bar-color-factor-custom"
  [1] "Running test: plotly-color-scatterplot-color-numeric"
  [1] "Running test: plotly-color-scatterplot-color-numeric-custom"
  [1] "Running test: plotly-color-scatterplot-scatter3d-axes"
  [1] "Running test: plotly-color-color-manual"
  [1] "Running test: plotly-colorbar"
  [1] "Running test: plotly-colorbar-expand"
  [1] "Running test: plotly-colorbar-restrict"
  [1] "Running test: plotly-colorbar-z-expand"
  [1] "Running test: plotly-colorbar-z-restrict"
  [1] "Running test: plotly-NAs"
  [1] "Running test: plotly-NAs-connect"
  [1] "Running test: plotly-NAs-within-group"
  [1] "Running test: plotly-NAs-within-color"
  [1] "Running test: plotly-NAs-within-color2"
  [1] "Running test: plotly-no-NAs-for-irrelevant-group"
  [1] "Running test: plotly-linetype-linetype"
  [1] "Running test: plotly-linetype-linetype2"
  [1] "Running test: plotly-linetype-linetype3"
  [1] "Running test: plotly-linetype-manual"
  [1] "Running test: plotly-linetype-ordering"
  [1] "Running test: plotly-linetype-alphabetical"
  [1] "Running test: plotly-subplot-simple"
  [1] "Running test: plotly-subplot-simple2"
  [1] "Running test: plotly-subplot-group"
  [1] "Running test: plotly-subplot-shareX"
  [1] "Running test: plotly-subplot-shareY"
  [1] "Running test: plotly-subplot-shareBoth"
  ── 249. Error: (unknown) (@test-plotly-subplot.R#82)  ──────────────────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: subplot(hist_top, empty, scatter, hist_right, nrows = 2, widths = c(0.8, 0.2), heights = c(0.2, 
         0.8), margin = 0.005, shareX = TRUE, shareY = TRUE) at testthat/test-plotly-subplot.R:82
  2: lapply(plots, function(d) plotly_build(d, registerFrames = FALSE)[["x"]])
  3: FUN(X[[i]], ...)
  4: plotly_build(d, registerFrames = FALSE)
  5: plotly_build.gg(d, registerFrames = FALSE)
  6: plotly_build(ggplotly(p))
  7: ggplotly(p)
  8: ggplotly.ggplot(p)
  9: gg2list(p, width = width, height = height, tooltip = tooltip, dynamicTicks = dynamicTicks, 
         layerData = layerData, originalData = originalData, source = source, ...)
  10: unitConvert(theme$plot.margin, "pixels")
  11: grid::convertHeight(u, "npc")
  12: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  13: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  [1] "Running test: plotly-symbol-scatterplot-symbol"
  [1] "Running test: plotly-symbol-scatterplot-symbol2"
  [1] "Running test: plotly-symbol-pch"
  [1] "Running test: plotly-symbol-logical"
  [1] "Running test: plotly-symbol-symbol-manual"
  [1] "Running test: plotly-symbol-ordering"
  [1] "Running test: plotly-symbol-alphabetical"
  [1] "Running test: plotly-scatterplot"
  [1] "Running test: plotly-bar-inference"
  [1] "Running test: plotly-box-data-array"
  [1] "Running test: plotly-group-within-trace"
  [1] "Running test: plotly-alpha-blending"
  [1] "Running test: plotly-alpha-no-color"
  [1] "Running test: plotly-factor-axis"
  [1] "Running test: plotly-character-axis"
  [1] "Running test: plotly-histogram"
  [1] "Running test: plotly-histogram-vert"
  [1] "Running test: plotly-inherit-FALSE"
  [1] "Running test: plotly-time-series-summary"
  ── 250. Error: no axis rotation is fine (@test-rotated-ticks.R#48)  ────────────
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: renderHTML(fg) at testthat/test-rotated-ticks.R:48
  2: gg2list(gg) at testthat/test-rotated-ticks.R:44
  3: unitConvert(theme$plot.margin, "pixels")
  4: grid::convertHeight(u, "npc")
  5: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  6: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 251. Error: axis.text.x=element_text(angle=90)" (@test-rotated-ticks.R#54)  ─
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: renderHTML(rotated) at testthat/test-rotated-ticks.R:54
  2: gg2list(gg) at testthat/test-rotated-ticks.R:44
  3: unitConvert(theme$plot.margin, "pixels")
  4: grid::convertHeight(u, "npc")
  5: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  6: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ── 252. Error: axis.text.x=element_text(angle=70) means transform="rotate(-70)" 
  VECTOR_ELT() can only be applied to a 'list', not a 'double'
  1: renderHTML(rotated) at testthat/test-rotated-ticks.R:60
  2: gg2list(gg) at testthat/test-rotated-ticks.R:44
  3: unitConvert(theme$plot.margin, "pixels")
  4: grid::convertHeight(u, "npc")
  5: convertUnit(x, unitTo, "y", "dimension", "y", "dimension", valueOnly = valueOnly)
  6: grid.Call(C_convert, x, as.integer(whatfrom), as.integer(whatto), valid.units(unitTo))
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 442 SKIPPED: 30 FAILED: 252
  1. Error: SharedData produces key/set in ggplotly (@test-animate-highlight.R#18) 
  2. Error: When key is equivalent to group, produce simple keys (@test-animate-highlight.R#91) 
  3. Error: When key is nested within group, produce simple key (@test-animate-highlight.R#121) 
  4. Error: Key structure is passed along to frame data (@test-animate-highlight.R#149) 
  5. Error: animation frames are boxed up correctly (@test-animate-highlight.R#345) 
  6. Error: sf works with crosstalk (@test-animate-highlight.R#382) 
  7. Error: factor levels determine tick order (@test-cookbook-axes.R#28) 
  8. Error: ylim hides points (@test-cookbook-axes.R#36) 
  9. Error: scale_y(limits) hides points (@test-cookbook-axes.R#41) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted