Running ‘testthat.R’ [7s/13s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(ggrepel)
  Loading required package: ggplot2
  > 
  > test_check("ggrepel")
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), point.padding = to_unit(point.padding), 
      segment.colour = segment.colour, segment.size = segment.size, 
      segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
      arrow = arrow, force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "textrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_text_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      point.padding = to_unit(point.padding), segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "textrepeltree"))
  where 5: f(...)
  where 6: (function (...) 
  f(...))(data, panel_params, coord, parse = FALSE, na.rm = FALSE, 
      box.padding = 0.25, point.padding = 1e-06, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, force = 1, max.iter = 2000, nudge_x = 0, nudge_y = 0, 
      xlim = c(NA, NA), ylim = c(NA, NA), direction = "both", seed = NA)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#27: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#19: test_that("calling geom_text_repel without seed creates different plots", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          png("testthat_test-seed1.png")
          p1 <- ggplot(dat1) + geom_text_repel(aes(wt, mpg, label = label))
          print(p1)
          grid.force()
          pos1 <- pos_df(grid.get("textrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed1.png")
          png("testthat_test-seed2.png")
          p2 <- ggplot(dat1) + geom_text_repel(aes(wt, mpg, label = label))
          print(p2)
          grid.force()
          pos2 <- pos_df(grid.get("textrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed2.png")
          expect_true(nrow(pos1) == nrow(dat1))
          expect_true(nrow(pos2) == nrow(dat1))
          expect_true(!identical(pos1, pos2))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 1. Error: calling geom_text_repel without seed creates different plots (@test
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(...)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), point.padding = to_unit(point.padding), 
      segment.colour = segment.colour, segment.size = segment.size, 
      segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
      arrow = arrow, force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "textrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_text_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      point.padding = to_unit(point.padding), segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "textrepeltree"))
  where 5: f(...)
  where 6: (function (...) 
  f(...))(data, panel_params, coord, parse = FALSE, na.rm = FALSE, 
      box.padding = 0.25, point.padding = 1e-06, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, force = 1, max.iter = 2000, nudge_x = 0, nudge_y = 0, 
      xlim = c(NA, NA), ylim = c(NA, NA), direction = "both", seed = 10)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#56: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#48: test_that("calling geom_text_repel with seed creates identical plots", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          png("testthat_test-seed1.png")
          p1 <- ggplot(dat1) + geom_text_repel(aes(wt, mpg, label = label), 
              seed = 10)
          print(p1)
          grid.force()
          pos1 <- pos_df(grid.get("textrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed1.png")
          png("testthat_test-seed2.png")
          p2 <- ggplot(dat1) + geom_text_repel(aes(wt, mpg, label = label), 
              seed = 10)
          print(p2)
          grid.force()
          pos2 <- pos_df(grid.get("textrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed2.png")
          expect_true(nrow(pos1) == nrow(dat1))
          expect_true(nrow(pos2) == nrow(dat1))
          expect_true(identical(pos1, pos2))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 2. Error: calling geom_text_repel with seed creates identical plots (@test-se
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(...)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), label.padding = to_unit(label.padding), 
      point.padding = to_unit(point.padding), label.r = to_unit(label.r), 
      label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_label_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
      label.r = to_unit(label.r), label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree"))
  where 5: f(..., self = self)
  where 6: (function (...) 
  f(..., self = self))(data, panel_params, coord, parse = FALSE, 
      box.padding = 0.25, label.padding = 0.25, point.padding = 1e-06, 
      label.r = 0.15, label.size = 0.25, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, na.rm = FALSE, force = 1, max.iter = 2000, 
      nudge_x = 0, nudge_y = 0, xlim = c(NA, NA), ylim = c(NA, 
      NA), direction = "both", seed = NA)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#88: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#77: test_that("calling geom_text_repel without seed does not remove entropy", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          random_seq = c()
          for (s in 1:2) {
              set.seed(s)
              png("testthat_test-seed1.png")
              p1 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, 
                  label = label))
              print(p1)
              dev.off()
              unlink("testthat_test-seed1.png")
              random_seq = c(random_seq, rnorm(1))
          }
          expect_true(length(unique(random_seq)) == length(random_seq))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 3. Error: calling geom_text_repel without seed does not remove entropy (@test
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(..., self = self)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), label.padding = to_unit(label.padding), 
      point.padding = to_unit(point.padding), label.r = to_unit(label.r), 
      label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_label_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
      label.r = to_unit(label.r), label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree"))
  where 5: f(..., self = self)
  where 6: (function (...) 
  f(..., self = self))(data, panel_params, coord, parse = FALSE, 
      box.padding = 0.25, label.padding = 0.25, point.padding = 1e-06, 
      label.r = 0.15, label.size = 0.25, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, na.rm = FALSE, force = 1, max.iter = 2000, 
      nudge_x = 0, nudge_y = 0, xlim = c(NA, NA), ylim = c(NA, 
      NA), direction = "both", seed = NA)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#107: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#99: test_that("calling geom_label_repel without seed creates different plots", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          png("testthat_test-seed1.png")
          p1 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, label = label))
          print(p1)
          grid.force()
          pos1 <- pos_df(grid.get("labelrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed1.png")
          png("testthat_test-seed2.png")
          p2 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, label = label))
          print(p2)
          grid.force()
          pos2 <- pos_df(grid.get("labelrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed2.png")
          expect_true(nrow(pos1) == nrow(dat1))
          expect_true(nrow(pos2) == nrow(dat1))
          expect_true(!identical(pos1, pos2))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 4. Error: calling geom_label_repel without seed creates different plots (@tes
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(..., self = self)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), label.padding = to_unit(label.padding), 
      point.padding = to_unit(point.padding), label.r = to_unit(label.r), 
      label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_label_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
      label.r = to_unit(label.r), label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree"))
  where 5: f(..., self = self)
  where 6: (function (...) 
  f(..., self = self))(data, panel_params, coord, parse = FALSE, 
      box.padding = 0.25, label.padding = 0.25, point.padding = 1e-06, 
      label.r = 0.15, label.size = 0.25, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, na.rm = FALSE, force = 1, max.iter = 2000, 
      nudge_x = 0, nudge_y = 0, xlim = c(NA, NA), ylim = c(NA, 
      NA), direction = "both", seed = 10)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#136: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#128: test_that("calling geom_label_repel with seed creates identical plots", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          png("testthat_test-seed1.png")
          p1 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, label = label), 
              seed = 10)
          print(p1)
          grid.force()
          pos1 <- pos_df(grid.get("labelrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed1.png")
          png("testthat_test-seed2.png")
          p2 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, label = label), 
              seed = 10)
          print(p2)
          grid.force()
          pos2 <- pos_df(grid.get("labelrepelgrob", grep = TRUE, 
              global = TRUE))
          dev.off()
          unlink("testthat_test-seed2.png")
          expect_true(nrow(pos1) == nrow(dat1))
          expect_true(nrow(pos2) == nrow(dat1))
          expect_true(identical(pos1, pos2))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 5. Error: calling geom_label_repel with seed creates identical plots (@test-s
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(..., self = self)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: gTree(limits = limits, data = data, lab = lab, nudges = nudges, 
      box.padding = to_unit(box.padding), label.padding = to_unit(label.padding), 
      point.padding = to_unit(point.padding), label.r = to_unit(label.r), 
      label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree")
  where 3: grobName(grob, prefix)
  where 4: ggname("geom_label_repel", gTree(limits = limits, data = data, 
      lab = lab, nudges = nudges, box.padding = to_unit(box.padding), 
      label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
      label.r = to_unit(label.r), label.size = label.size, segment.colour = segment.colour, 
      segment.size = segment.size, segment.alpha = segment.alpha, 
      min.segment.length = to_unit(min.segment.length), arrow = arrow, 
      force = force, max.iter = max.iter, direction = direction, 
      seed = seed, cl = "labelrepeltree"))
  where 5: f(..., self = self)
  where 6: (function (...) 
  f(..., self = self))(data, panel_params, coord, parse = FALSE, 
      box.padding = 0.25, label.padding = 0.25, point.padding = 1e-06, 
      label.r = 0.15, label.size = 0.25, segment.colour = NULL, 
      segment.size = 0.5, segment.alpha = NULL, min.segment.length = 0.5, 
      arrow = NULL, na.rm = FALSE, force = 1, max.iter = 2000, 
      nudge_x = 0, nudge_y = 0, xlim = c(NA, NA), ylim = c(NA, 
      NA), direction = "both", seed = NA)
  where 7: do.call(self$draw_panel, args)
  where 8: FUN(X[[i]], ...)
  where 9: lapply(split(data, data$PANEL), function(data) {
      if (empty(data)) 
          return(zeroGrob())
      panel_params <- layout$panel_params[[data$PANEL[1]]]
      do.call(self$draw_panel, args)
  })
  where 10: f(..., self = self)
  where 11: self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
  where 12: f(..., self = self)
  where 13: l$draw_geom(d, layout)
  where 14: (function (l, d) 
  l$draw_geom(d, layout))(dots[[1L]][[1L]], dots[[2L]][[1L]])
  where 15: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  where 16: Map(function(l, d) l$draw_geom(d, layout), plot$layers, data)
  where 17: ggplot_gtable.ggplot_built(data)
  where 18: ggplot_gtable(data)
  where 19: print.ggplot(p1)
  where 20 at testthat/test-seed.R#168: print(p1)
  where 21: eval(code, test_env)
  where 22: eval(code, test_env)
  where 23: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 24: doTryCatch(return(expr), name, parentenv, handler)
  where 25: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 26: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 29: tryCatchList(expr, classes, parentenv, handlers)
  where 30: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 31: test_code(desc, code, env = parent.frame())
  where 32 at testthat/test-seed.R#157: test_that("calling geom_label_repel without seed does not remove entropy", 
      {
          ix <- seq(1, nrow(mtcars), 4)
          dat1 <- mtcars[ix, ]
          dat1$label <- rownames(mtcars)[ix]
          random_seq = c()
          for (s in 1:2) {
              set.seed(s)
              png("testthat_test-seed1.png")
              p1 <- ggplot(dat1) + geom_label_repel(aes(wt, mpg, 
                  label = label))
              print(p1)
              dev.off()
              unlink("testthat_test-seed1.png")
              random_seq = c(random_seq, rnorm(1))
          }
          expect_true(length(unique(random_seq)) == length(random_seq))
      })
  where 33: eval(code, test_env)
  where 34: eval(code, test_env)
  where 35: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 36: doTryCatch(return(expr), name, parentenv, handler)
  where 37: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 38: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 39: doTryCatch(return(expr), name, parentenv, handler)
  where 40: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 41: tryCatchList(expr, classes, parentenv, handlers)
  where 42: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 43: test_code(NULL, exprs, env)
  where 44: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 45: force(code)
  where 46: doWithOneRestart(return(expr), restart)
  where 47: withOneRestart(expr, restarts[[1L]])
  where 48: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 49: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 50: FUN(X[[i]], ...)
  where 51: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 52: force(code)
  where 53: doWithOneRestart(return(expr), restart)
  where 54: withOneRestart(expr, restarts[[1L]])
  where 55: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 56: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 57: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 58: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 59: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 60: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 6. Error: calling geom_label_repel without seed does not remove entropy (@tes
  the condition has length > 1
  Backtrace:
    1. base::print(p1)
    2. ggplot2:::print.ggplot(p1)
    4. ggplot2:::ggplot_gtable.ggplot_built(data)
    5. base::Map(...)
    6. base::mapply(FUN = f, ..., SIMPLIFY = FALSE)
    8. l$draw_geom(d, layout)
    9. ggplot2:::f(..., self = self)
   10. self$geom$draw_layer(data, self$geom_params, layout, layout$coord)
   11. ggplot2:::f(..., self = self)
   12. base::lapply(...)
   13. ggplot2:::FUN(X[[i]], ...)
   16. ggrepel:::f(..., self = self)
   20. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomLabelRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, box.padding = to_unit(box.padding), 
          label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
          label.r = to_unit(label.r), label.size = label.size, 
          segment.colour = segment.color %||% segment.colour, segment.size = segment.size, 
          segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
          arrow = arrow, na.rm = na.rm, force = force, max.iter = max.iter, 
          nudge_x = nudge_x, nudge_y = nudge_y, xlim = xlim, ylim = ylim, 
          direction = match.arg(direction), seed = seed, ...))
  where 3 at testthat/test-to_unit.R#43: geom_label_repel(box.padding = unit(1, "lines"), label.padding = unit(2, 
      "lines"), point.padding = unit(3, "lines"), label.r = unit(4, 
      "lines"), min.segment.length = unit(5, "lines"))
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#41: test_that("non-default values as units work with geom_label_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, label = b)) + geom_point() + 
              geom_label_repel(box.padding = unit(1, "lines"), 
                  label.padding = unit(2, "lines"), point.padding = unit(3, 
                    "lines"), label.r = unit(4, "lines"), min.segment.length = unit(5, 
                    "lines"))
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "label.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(3, 
              "lines"))
          expect_identical(extract_param(p, "label.r"), unit(4, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(5, "lines"))
      })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 7. Error: non-default values as units work with geom_label_repel (@test-to_un
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_label_repel(...)
   3. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomTextRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, na.rm = na.rm, box.padding = to_unit(box.padding), 
          point.padding = to_unit(point.padding), segment.colour = segment.color %||% 
              segment.colour, segment.size = segment.size, segment.alpha = segment.alpha, 
          min.segment.length = to_unit(min.segment.length), arrow = arrow, 
          force = force, max.iter = max.iter, nudge_x = nudge_x, 
          nudge_y = nudge_y, xlim = xlim, ylim = ylim, direction = match.arg(direction), 
          seed = seed, ...))
  where 3 at testthat/test-to_unit.R#58: geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
      "lines"), min.segment.length = unit(3, "lines"))
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#56: test_that("non-default values as units work with geom_text_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, text = b)) + geom_point() + 
              geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
                  "lines"), min.segment.length = unit(3, "lines"))
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(3, "lines"))
      })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 8. Error: non-default values as units work with geom_text_repel (@test-to_uni
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_text_repel(...)
   3. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomLabelRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, box.padding = to_unit(box.padding), 
          label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
          label.r = to_unit(label.r), label.size = label.size, 
          segment.colour = segment.color %||% segment.colour, segment.size = segment.size, 
          segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
          arrow = arrow, na.rm = na.rm, force = force, max.iter = max.iter, 
          nudge_x = nudge_x, nudge_y = nudge_y, xlim = xlim, ylim = ylim, 
          direction = match.arg(direction), seed = seed, ...))
  where 3: geom_label_repel(box.padding = unit(1, "lines"), label.padding = unit(2, 
      "lines"), point.padding = unit(3, "lines"), label.r = unit(4, 
      "lines"), min.segment.length = unit(5, "lines"))
  where 4: eval_bare(expr, quo_get_env(quo))
  where 5: quasi_label(enquo(expected), expected.label, arg = "expected")
  where 6 at testthat/test-to_unit.R#107: expect_equal(p, ggplot(d, aes(x, y, label = b)) + geom_point() + 
      geom_label_repel(box.padding = unit(1, "lines"), label.padding = unit(2, 
          "lines"), point.padding = unit(3, "lines"), label.r = unit(4, 
          "lines"), min.segment.length = unit(5, "lines")))
  where 7: eval(code, test_env)
  where 8: eval(code, test_env)
  where 9: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 13: doTryCatch(return(expr), name, parentenv, handler)
  where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 15: tryCatchList(expr, classes, parentenv, handlers)
  where 16: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 17: test_code(desc, code, env = parent.frame())
  where 18 at testthat/test-to_unit.R#96: test_that("non-default values as numbers work with geom_label_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, label = b)) + geom_point() + 
              geom_label_repel(box.padding = 1, label.padding = 2, 
                  point.padding = 3, label.r = 4, min.segment.length = 5)
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "label.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(3, 
              "lines"))
          expect_identical(extract_param(p, "label.r"), unit(4, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(5, "lines"))
          expect_equal(p, ggplot(d, aes(x, y, label = b)) + geom_point() + 
              geom_label_repel(box.padding = unit(1, "lines"), 
                  label.padding = unit(2, "lines"), point.padding = unit(3, 
                    "lines"), label.r = unit(4, "lines"), min.segment.length = unit(5, 
                    "lines")))
      })
  where 19: eval(code, test_env)
  where 20: eval(code, test_env)
  where 21: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 25: doTryCatch(return(expr), name, parentenv, handler)
  where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 27: tryCatchList(expr, classes, parentenv, handlers)
  where 28: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 29: test_code(NULL, exprs, env)
  where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 31: force(code)
  where 32: doWithOneRestart(return(expr), restart)
  where 33: withOneRestart(expr, restarts[[1L]])
  where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 36: FUN(X[[i]], ...)
  where 37: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 38: force(code)
  where 39: doWithOneRestart(return(expr), restart)
  where 40: withOneRestart(expr, restarts[[1L]])
  where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 42: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 45: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 46: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 9. Error: non-default values as numbers work with geom_label_repel (@test-to_
  the condition has length > 1
  Backtrace:
   1. testthat::expect_equal(...)
   4. ggrepel::geom_label_repel(...)
   6. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomTextRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, na.rm = na.rm, box.padding = to_unit(box.padding), 
          point.padding = to_unit(point.padding), segment.colour = segment.color %||% 
              segment.colour, segment.size = segment.size, segment.alpha = segment.alpha, 
          min.segment.length = to_unit(min.segment.length), arrow = arrow, 
          force = force, max.iter = max.iter, nudge_x = nudge_x, 
          nudge_y = nudge_y, xlim = xlim, ylim = ylim, direction = match.arg(direction), 
          seed = seed, ...))
  where 3: geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
      "lines"), min.segment.length = unit(3, "lines"))
  where 4: eval_bare(expr, quo_get_env(quo))
  where 5: quasi_label(enquo(expected), expected.label, arg = "expected")
  where 6 at testthat/test-to_unit.R#123: expect_equal(p, ggplot(d, aes(x, y, text = b)) + geom_point() + 
      geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
          "lines"), min.segment.length = unit(3, "lines")))
  where 7: eval(code, test_env)
  where 8: eval(code, test_env)
  where 9: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 13: doTryCatch(return(expr), name, parentenv, handler)
  where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 15: tryCatchList(expr, classes, parentenv, handlers)
  where 16: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 17: test_code(desc, code, env = parent.frame())
  where 18 at testthat/test-to_unit.R#114: test_that("non-default values as numbers work with geom_text_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, text = b)) + geom_point() + 
              geom_text_repel(box.padding = 1, point.padding = 2, 
                  min.segment.length = 3)
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(3, "lines"))
          expect_equal(p, ggplot(d, aes(x, y, text = b)) + geom_point() + 
              geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
                  "lines"), min.segment.length = unit(3, "lines")))
      })
  where 19: eval(code, test_env)
  where 20: eval(code, test_env)
  where 21: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 25: doTryCatch(return(expr), name, parentenv, handler)
  where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 27: tryCatchList(expr, classes, parentenv, handlers)
  where 28: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 29: test_code(NULL, exprs, env)
  where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 31: force(code)
  where 32: doWithOneRestart(return(expr), restart)
  where 33: withOneRestart(expr, restarts[[1L]])
  where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 36: FUN(X[[i]], ...)
  where 37: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 38: force(code)
  where 39: doWithOneRestart(return(expr), restart)
  where 40: withOneRestart(expr, restarts[[1L]])
  where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 42: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 45: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 46: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 10. Error: non-default values as numbers work with geom_text_repel (@test-to_
  the condition has length > 1
  Backtrace:
   1. testthat::expect_equal(...)
   4. ggrepel::geom_text_repel(...)
   6. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomLabelRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, box.padding = to_unit(box.padding), 
          label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
          label.r = to_unit(label.r), label.size = label.size, 
          segment.colour = segment.color %||% segment.colour, segment.size = segment.size, 
          segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
          arrow = arrow, na.rm = na.rm, force = force, max.iter = max.iter, 
          nudge_x = nudge_x, nudge_y = nudge_y, xlim = xlim, ylim = ylim, 
          direction = match.arg(direction), seed = seed, ...))
  where 3 at testthat/test-to_unit.R#131: geom_label_repel(box.padding = unit(1, "lines"), label.padding = 2, 
      point.padding = 3, label.r = unit(4, "lines"), min.segment.length = 5)
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#129: test_that("non-default values as mix of units and numbers work with geom_label_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, label = b)) + geom_point() + 
              geom_label_repel(box.padding = unit(1, "lines"), 
                  label.padding = 2, point.padding = 3, label.r = unit(4, 
                    "lines"), min.segment.length = 5)
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "label.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(3, 
              "lines"))
          expect_identical(extract_param(p, "label.r"), unit(4, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(5, "lines"))
          expect_equal(p, ggplot(d, aes(x, y, label = b)) + geom_point() + 
              geom_label_repel(box.padding = unit(1, "lines"), 
                  label.padding = unit(2, "lines"), point.padding = unit(3, 
                    "lines"), label.r = unit(4, "lines"), min.segment.length = unit(5, 
                    "lines")))
      })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 11. Error: non-default values as mix of units and numbers work with geom_labe
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_label_repel(...)
   3. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(point.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(point.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomTextRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, na.rm = na.rm, box.padding = to_unit(box.padding), 
          point.padding = to_unit(point.padding), segment.colour = segment.color %||% 
              segment.colour, segment.size = segment.size, segment.alpha = segment.alpha, 
          min.segment.length = to_unit(min.segment.length), arrow = arrow, 
          force = force, max.iter = max.iter, nudge_x = nudge_x, 
          nudge_y = nudge_y, xlim = xlim, ylim = ylim, direction = match.arg(direction), 
          seed = seed, ...))
  where 3 at testthat/test-to_unit.R#149: geom_text_repel(box.padding = 1, point.padding = unit(2, "lines"), 
      min.segment.length = 3)
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#147: test_that("non-default values as mix of units and numbers work with geom_text_repel", 
      {
          d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
          p <- ggplot(d, aes(x, y, text = b)) + geom_point() + 
              geom_text_repel(box.padding = 1, point.padding = unit(2, 
                  "lines"), min.segment.length = 3)
          expect_identical(extract_param(p, "box.padding"), unit(1, 
              "lines"))
          expect_identical(extract_param(p, "point.padding"), unit(2, 
              "lines"))
          expect_identical(extract_param(p, "min.segment.length"), 
              unit(3, "lines"))
          expect_equal(p, ggplot(d, aes(x, y, text = b)) + geom_point() + 
              geom_text_repel(box.padding = unit(1, "lines"), point.padding = unit(2, 
                  "lines"), min.segment.length = unit(3, "lines")))
      })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 12. Error: non-default values as mix of units and numbers work with geom_text
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_text_repel(...)
   3. ggrepel:::to_unit(point.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(box.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(box.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomLabelRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, box.padding = to_unit(box.padding), 
          label.padding = to_unit(label.padding), point.padding = to_unit(point.padding), 
          label.r = to_unit(label.r), label.size = label.size, 
          segment.colour = segment.color %||% segment.colour, segment.size = segment.size, 
          segment.alpha = segment.alpha, min.segment.length = to_unit(min.segment.length), 
          arrow = arrow, na.rm = na.rm, force = force, max.iter = max.iter, 
          nudge_x = nudge_x, nudge_y = nudge_y, xlim = xlim, ylim = ylim, 
          direction = match.arg(direction), seed = seed, ...))
  where 3 at testthat/test-to_unit.R#164: geom_label_repel(box.padding = unit(1, "cm"), label.padding = 2, 
      point.padding = 3, label.r = unit(4, "cm"), min.segment.length = 5)
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#162: test_that("non-line units work with geom_label_repel", {
      d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
      p <- ggplot(d, aes(x, y, label = b)) + geom_point() + geom_label_repel(box.padding = unit(1, 
          "cm"), label.padding = 2, point.padding = 3, label.r = unit(4, 
          "cm"), min.segment.length = 5)
      expect_identical(extract_param(p, "box.padding"), unit(1, 
          "cm"))
      expect_identical(extract_param(p, "label.padding"), unit(2, 
          "lines"))
      expect_identical(extract_param(p, "point.padding"), unit(3, 
          "lines"))
      expect_identical(extract_param(p, "label.r"), unit(4, "cm"))
      expect_identical(extract_param(p, "min.segment.length"), 
          unit(5, "lines"))
  })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 13. Error: non-line units work with geom_label_repel (@test-to_unit.R#164)  ─
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_label_repel(...)
   3. ggrepel:::to_unit(box.padding)
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  ggrepel
   --- call from context --- 
  to_unit(point.padding)
   --- call from argument --- 
  if (class(x) == "unit") {
      return(x)
  }
   --- R stacktrace ---
  where 1: to_unit(point.padding)
  where 2: layer(data = data, mapping = mapping, stat = stat, geom = GeomTextRepel, 
      position = position, show.legend = show.legend, inherit.aes = inherit.aes, 
      params = list(parse = parse, na.rm = na.rm, box.padding = to_unit(box.padding), 
          point.padding = to_unit(point.padding), segment.colour = segment.color %||% 
              segment.colour, segment.size = segment.size, segment.alpha = segment.alpha, 
          min.segment.length = to_unit(min.segment.length), arrow = arrow, 
          force = force, max.iter = max.iter, nudge_x = nudge_x, 
          nudge_y = nudge_y, xlim = xlim, ylim = ylim, direction = match.arg(direction), 
          seed = seed, ...))
  where 3 at testthat/test-to_unit.R#177: geom_text_repel(box.padding = 1, point.padding = unit(2, "cm"), 
      min.segment.length = 3)
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test-to_unit.R#175: test_that("non-line units work with geom_text_repel", {
      d <- data.frame(x = rnorm(10), y = rnorm(10), b = letters[1:10])
      p <- ggplot(d, aes(x, y, text = b)) + geom_point() + geom_text_repel(box.padding = 1, 
          point.padding = unit(2, "cm"), min.segment.length = 3)
      expect_identical(extract_param(p, "box.padding"), unit(1, 
          "lines"))
      expect_identical(extract_param(p, "point.padding"), unit(2, 
          "cm"))
      expect_identical(extract_param(p, "min.segment.length"), 
          unit(3, "lines"))
  })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("ggrepel")
  
   --- value of length: 3 type: logical ---
  [1] FALSE  TRUE FALSE
   --- function from context --- 
  function (x) 
  {
      if (class(x) == "unit") {
          return(x)
      }
      if (is.na(x)) {
          return(NA)
      }
      unit(x, "lines")
  }
  <bytecode: 0x3130a50>
  <environment: namespace:ggrepel>
   --- function search by body ---
  Function to_unit in namespace ggrepel has this body.
   ----------- END OF FAILURE REPORT -------------- 
  ── 14. Error: non-line units work with geom_text_repel (@test-to_unit.R#177)  ──
  the condition has length > 1
  Backtrace:
   1. ggrepel::geom_text_repel(...)
   3. ggrepel:::to_unit(point.padding)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  [ OK: 30 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 14 ]
  1. Error: calling geom_text_repel without seed creates different plots (@test-seed.R#27) 
  2. Error: calling geom_text_repel with seed creates identical plots (@test-seed.R#56) 
  3. Error: calling geom_text_repel without seed does not remove entropy (@test-seed.R#88) 
  4. Error: calling geom_label_repel without seed creates different plots (@test-seed.R#107) 
  5. Error: calling geom_label_repel with seed creates identical plots (@test-seed.R#136) 
  6. Error: calling geom_label_repel without seed does not remove entropy (@test-seed.R#168) 
  7. Error: non-default values as units work with geom_label_repel (@test-to_unit.R#43) 
  8. Error: non-default values as units work with geom_text_repel (@test-to_unit.R#58) 
  9. Error: non-default values as numbers work with geom_label_repel (@test-to_unit.R#107) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted