Running 'test-all.R' [7s]
Running the tests in 'tests/test-all.R' failed.
Complete output:
  > 
  > library(testthat)
  > 
  > test_check("prettymapr")
  Loading required package: prettymapr
  -- 1. Error: geocode output is consistent (@test_geocode.R#8)  -----------------
  $ operator is invalid for atomic vectors
  1: geocode("wolfville, ns", output = "data.frame", source = source) at testthat/test_geocode.R:8
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: loop_apply(n, do.ply)
  6: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  7: .fun(piece, ...)
  8: geocoder_partial(row$query)
  9: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  10: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  11: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  12: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  13: loop_apply(n, do.ply)
  14: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  15: .fun(piece, ...)
  
  -- 2. Error: emptys and nulls produce the correct output (@test_geocode.R#65)  -
  $ operator is invalid for atomic vectors
  1: geocode("wolfville, ns", output = "data.frame") at testthat/test_geocode.R:65
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: loop_apply(n, do.ply)
  6: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  7: .fun(piece, ...)
  8: geocoder_partial(row$query)
  9: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  10: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  11: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  12: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  13: loop_apply(n, do.ply)
  14: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  15: .fun(piece, ...)
  
  
  |                                                    |  0%                      -- 3. Error: output is vectorized with correct lengths (@test_geocode.R#75)  ---
  $ operator is invalid for atomic vectors
  1: geocode(cities, output = "data.frame", source = "pickpoint") at testthat/test_geocode.R:75
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: loop_apply(n, do.ply)
  6: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  7: .fun(piece, ...)
  8: geocoder_partial(row$query)
  9: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  10: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  11: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  12: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  13: loop_apply(n, do.ply)
  14: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  15: .fun(piece, ...)
  
  -- 4. Error: output is vectorized with correct lengths (@test_geocode.R#75)  ---
  argument is of length zero
  1: geocode(cities, output = "data.frame", source = "pickpoint") at testthat/test_geocode.R:75
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: progress$term()
  6: close(txt)
  7: close.txtProgressBar(txt)
  8: con$kill()
  
  -- 5. Error: invalid parameters are detected (@test_geocode.R#101)  ------------
  $ operator is invalid for atomic vectors
  1: expect_message(geocode("something", messaging = TRUE), "Parameter 'messaging' is deprecated. Use 'quiet = FALSE' instead") at testthat/test_geocode.R:101
  2: quasi_capture(enquo(object), capture_messages, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, message = function(condition) {
         out$push(condition)
         invokeRestart("muffleMessage")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: geocode("something", messaging = TRUE)
  7: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  8: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  9: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  10: loop_apply(n, do.ply)
  11: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  12: .fun(piece, ...)
  13: geocoder_partial(row$query)
  14: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  15: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  16: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  17: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  18: loop_apply(n, do.ply)
  19: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  20: .fun(piece, ...)
  
  -- 6. Error: mesages are printed when defaults are guessed (@test_geocode.R#110)
  $ operator is invalid for atomic vectors
  1: expect_message(geocode("something"), "Using default API key for pickpoint.io.") at testthat/test_geocode.R:110
  2: quasi_capture(enquo(object), capture_messages, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: withCallingHandlers(code, message = function(condition) {
         out$push(condition)
         invokeRestart("muffleMessage")
     })
  5: eval_bare(get_expr(quo), get_env(quo))
  6: geocode("something")
  7: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  8: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  9: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  10: loop_apply(n, do.ply)
  11: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  12: .fun(piece, ...)
  13: geocoder_partial(row$query)
  14: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  15: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  16: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  17: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  18: loop_apply(n, do.ply)
  19: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  20: .fun(piece, ...)
  
  
  |                                                    |  0%                      -- 7. Error: vectors that contain zero-length input don't screw up the query / s
  $ operator is invalid for atomic vectors
  1: geocode(cities) at testthat/test_geocode.R:136
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: loop_apply(n, do.ply)
  6: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  7: .fun(piece, ...)
  8: geocoder_partial(row$query)
  9: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  10: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  11: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  12: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  13: loop_apply(n, do.ply)
  14: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  15: .fun(piece, ...)
  
  -- 8. Error: vectors that contain zero-length input don't screw up the query / s
  argument is of length zero
  1: geocode(cities) at testthat/test_geocode.R:136
  2: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  3: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  4: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  5: progress$term()
  6: close(txt)
  7: close.txtProgressBar(txt)
  8: con$kill()
  
  -- 9. Error: progress bar is hidden when appropriate (@test_geocode.R#148)  ----
  $ operator is invalid for atomic vectors
  1: expect_output(geocode(cities, key = "yxsN6E8EYYHFF_xsa_uL")) at testthat/test_geocode.R:148
  2: quasi_capture(enquo(object), capture_output, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: capture_output_lines(code, print, width = width)
  5: eval_with_output(code, print = print, width = width)
  6: withr::with_output_sink(temp, withVisible(code))
  7: force(code)
  8: withVisible(code)
  9: eval_bare(get_expr(quo), get_env(quo))
  10: geocode(cities, key = "yxsN6E8EYYHFF_xsa_uL")
  ...
  15: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  16: .fun(piece, ...)
  17: geocoder_partial(row$query)
  18: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  19: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  20: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  21: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  22: loop_apply(n, do.ply)
  23: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  24: .fun(piece, ...)
  
  -- 10. Error: progress bar is hidden when appropriate (@test_geocode.R#148)  ---
  argument is of length zero
  1: expect_output(geocode(cities, key = "yxsN6E8EYYHFF_xsa_uL")) at testthat/test_geocode.R:148
  2: quasi_capture(enquo(object), capture_output, label = label)
  3: capture(act$val <- eval_bare(get_expr(quo), get_env(quo)))
  4: capture_output_lines(code, print, width = width)
  5: eval_with_output(code, print = print, width = width)
  6: withr::with_output_sink(temp, withVisible(code))
  7: force(code)
  8: withVisible(code)
  9: eval_bare(get_expr(quo), get_env(quo))
  10: geocode(cities, key = "yxsN6E8EYYHFF_xsa_uL")
  11: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  12: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  13: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  14: progress$term()
  15: close(txt)
  16: close.txtProgressBar(txt)
  17: con$kill()
  
  -- 11. Error: setting the default source changes the source (@test_geocode.R#161
  $ operator is invalid for atomic vectors
  1: expect_equal(geocode("wolfville ns")$source, default_source) at testthat/test_geocode.R:161
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: geocode("wolfville ns")
  5: plyr::adply(df, 1, function(row) geocoder_partial(row$query), .progress = progress)
  6: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  7: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  8: loop_apply(n, do.ply)
  9: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  10: .fun(piece, ...)
  11: geocoder_partial(row$query)
  12: geocoder(loc, output = output, limit = limit, key = key, quiet = quiet, cache = cache, 
         ...)
  13: plyr::adply(df, 1, function(row) {
         result <- data[[row$rank]]
         boundingbox <- result$boundingbox
         if (length(boundingbox) != 4) {
             warning("Unexpected bounding box type for location ", location)
             boundingbox <- rep(NA_real_, 4)
         }
         fields <- list(address = result$display_name, lon = as.numeric(result$lon), lat = as.numeric(result$lat), 
             bbox_n = as.numeric(boundingbox[2]), bbox_e = as.numeric(boundingbox[4]), 
             bbox_s = as.numeric(boundingbox[1]), bbox_w = as.numeric(boundingbox[3]), 
             id = result$place_id)
         fields <- fields[!vapply(fields, function(x) length(x) == 0, logical(1))]
         data.frame(fields, stringsAsFactors = FALSE)
     })
  14: ldply(.data = pieces, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts, .id = .id)
  15: llply(.data = .data, .fun = .fun, ..., .progress = .progress, .inform = .inform, 
         .parallel = .parallel, .paropts = .paropts)
  16: loop_apply(n, do.ply)
  17: (function (i) 
     {
         piece <- pieces[[i]]
         if (.inform) {
             res <- try(.fun(piece, ...))
             if (inherits(res, "try-error")) {
                 piece <- paste(utils::capture.output(print(piece)), collapse = "\n")
                 stop("with piece ", i, ": \n", piece, call. = FALSE)
             }
         }
         else {
             res <- .fun(piece, ...)
         }
         progress$step()
         res
     })(1L)
  18: .fun(piece, ...)
  
  == testthat results  ===========================================================
  OK: 60 SKIPPED: 0 FAILED: 11
  1. Error: geocode output is consistent (@test_geocode.R#8) 
  2. Error: emptys and nulls produce the correct output (@test_geocode.R#65) 
  3. Error: output is vectorized with correct lengths (@test_geocode.R#75) 
  4. Error: output is vectorized with correct lengths (@test_geocode.R#75) 
  5. Error: invalid parameters are detected (@test_geocode.R#101) 
  6. Error: mesages are printed when defaults are guessed (@test_geocode.R#110) 
  7. Error: vectors that contain zero-length input don't screw up the query / source columns (@test_geocode.R#136) 
  8. Error: vectors that contain zero-length input don't screw up the query / source columns (@test_geocode.R#136) 
  9. Error: progress bar is hidden when appropriate (@test_geocode.R#148) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted