* using log directory ‘/data/gannet/ripley/R/packages/tests-LENGTH1/ggvoronoi.Rcheck’
* using R Under development (unstable) (2022-04-03 r82074)
* using platform: x86_64-pc-linux-gnu (64-bit)
* using session charset: UTF-8
* using option ‘--no-stop-on-test-error’
* checking for file ‘ggvoronoi/DESCRIPTION’ ... OK
* this is package ‘ggvoronoi’ version ‘0.8.4’
* package encoding: UTF-8
* checking package namespace information ... OK
* checking package dependencies ... OK
* checking if this is a source package ... OK
* checking if there is a namespace ... OK
* checking for executable files ... OK
* checking for hidden files and directories ... OK
* checking for portable file names ... OK
* checking for sufficient/correct file permissions ... OK
* checking whether package ‘ggvoronoi’ can be installed ... [48s/61s] OK
* checking package directory ... OK
* checking ‘build’ directory ... OK
* checking DESCRIPTION meta-information ... OK
* checking top-level files ... OK
* checking for left-over files ... OK
* checking index information ... OK
* checking package subdirectories ... OK
* checking R files for non-ASCII characters ... OK
* checking R files for syntax errors ... OK
* checking whether the package can be loaded ... OK
* checking whether the package can be loaded with stated dependencies ... OK
* checking whether the package can be unloaded cleanly ... OK
* checking whether the namespace can be loaded with stated dependencies ... OK
* checking whether the namespace can be unloaded cleanly ... OK
* checking loading without being on the library search path ... OK
* checking use of S3 registration ... OK
* checking dependencies in R code ... OK
* checking S3 generic/method consistency ... OK
* checking replacement functions ... OK
* checking foreign function calls ... OK
* checking R code for possible problems ... [54s/57s] OK
* checking Rd files ... OK
* checking Rd metadata ... OK
* checking Rd line widths ... OK
* checking Rd cross-references ... OK
* checking for missing documentation entries ... OK
* checking for code/documentation mismatches ... OK
* checking Rd \usage sections ... OK
* checking Rd contents ... OK
* checking for unstated dependencies in examples ... OK
* checking contents of ‘data’ directory ... OK
* checking data for non-ASCII characters ... OK
* checking LazyData ... OK
* checking data for ASCII and uncompressed saves ... OK
* checking installed files from ‘inst/doc’ ... OK
* checking files in ‘vignettes’ ... OK
* checking examples ... [12s/12s] OK
* checking for unstated dependencies in ‘tests’ ... OK
* checking tests ...
  Running ‘testthat.R’
 OK
* checking for unstated dependencies in vignettes ... OK
* checking package vignettes in ‘inst/doc’ ... OK
* checking re-building of vignette outputs ... [13s/13s] ERROR
Error(s) in re-building vignettes:
--- re-building ‘ggvoronoi.Rmd’ using rmarkdown
 ----------- FAILURE REPORT -------------- 
 --- failure: length > 1 in coercion to logical ---
 --- srcref --- 
: 
 --- package (from environment) --- 
ggmap
 --- call from context --- 
ggmap(oxford_map, base_layer = ggplot(data = oxford_bikes, aes(x, 
    y)))
 --- call from argument --- 
missing(base_layer) || base_layer == "auto"
 --- R stacktrace ---
where 1: ggmap(oxford_map, base_layer = ggplot(data = oxford_bikes, aes(x, 
    y)))
where 2: eval(expr, envir, enclos)
where 3: eval(expr, envir, enclos)
where 4: eval_with_user_handlers(expr, envir, enclos, user_handlers)
where 5: withVisible(eval_with_user_handlers(expr, envir, enclos, user_handlers))
where 6: withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)
where 7: handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler))
where 8: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)))
where 9: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, 
    debug = debug, last = i == length(out), use_try = stop_on_error != 
        2L, keep_warning = keep_warning, keep_message = keep_message, 
    output_handler = output_handler, include_timing = include_timing)
where 10: evaluate::evaluate(...)
where 11: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), 
    keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options))
where 12: in_dir(input_dir(), expr)
where 13: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
    keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), 
    stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options)))
where 14: eng_r(options)
where 15: block_exec(params)
where 16: call_block(x)
where 17: process_group.block(group)
where 18: process_group(group)
where 19: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    error = function(e) {
        setwd(wd)
        cat(res, sep = "\n", file = output %n% "")
        message("Quitting from lines ", paste(current_lines(i), 
            collapse = "-"), " (", knit_concord$get("infile"), 
            ") ")
    })
where 20: process_file(text, output)
where 21: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
where 22: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
    output_dir = getwd(), ...)
where 23: vweave_rmarkdown(...)
where 24: engine$weave(file, quiet = quiet, encoding = enc)
where 25: doTryCatch(return(expr), name, parentenv, handler)
where 26: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 27: tryCatchList(expr, classes, parentenv, handlers)
where 28: tryCatch({
    engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 
            engine = engine)
    }
    outputs <- c(outputs, output)
}, error = function(e) {
    thisOK <<- FALSE
    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
        file, conditionMessage(e)))
})
where 29: tools:::buildVignettes(dir = "/data/gannet/ripley/R/packages/tests-LENGTH1/ggvoronoi.Rcheck/vign_test/ggvoronoi")

 --- value of length: 9 type: logical ---
       data      layers      scales     mapping       theme coordinates 
      FALSE       FALSE       FALSE       FALSE       FALSE       FALSE 
      facet    plot_env      labels 
      FALSE       FALSE       FALSE 
 --- function from context --- 
function (ggmap, extent = "panel", base_layer, maprange = FALSE, 
    legend = "right", padding = 0.02, darken = c(0, "black"), 
    b, fullpage, expand, ...) 
{
    lon <- NULL
    rm(lon)
    lat <- NULL
    rm(lat)
    fill <- NULL
    rm(fill)
    ll.lon <- NULL
    rm(ll.lon)
    ur.lon <- NULL
    rm(ur.lon)
    ll.lat <- NULL
    rm(ll.lat)
    ur.lat <- NULL
    rm(ur.lat)
    if (!missing(b)) {
        .Deprecated(msg = "b syntax deprecated, use padding.")
        padding <- b
    }
    if (!missing(fullpage) || !missing(expand)) {
        .Deprecated(msg = "fullpage and expand syntaxes deprecated, use extent.")
        if (missing(fullpage)) {
            fullpage <- FALSE
        }
        if (missing(expand)) {
            expand <- FALSE
        }
        if (fullpage) 
            extent <- "device"
        if (fullpage == FALSE && expand == TRUE) 
            extent <- "panel"
        if (fullpage == FALSE && expand == FALSE) 
            extent <- "normal"
    }
    if (class(ggmap)[1] != "ggmap") {
        stop("ggmap plots objects of class ggmap, see ?get_map", 
            call. = FALSE)
    }
    match.arg(legend, c("right", "left", "bottom", "top", "bottomleft", 
        "bottomright", "topleft", "topright", "none"))
    if (is.language(darken)) 
        darken <- eval(darken)
    stopifnot(0 <= as.numeric(darken[1]) && as.numeric(darken[1]) <= 
        1)
    if (length(darken) == 1 & is.numeric(darken)) 
        darken <- c(darken, "black")
    if (missing(base_layer) || base_layer == "auto") {
        if (inherits(ggmap, "raster")) {
            fourCorners <- expand.grid(lon = as.numeric(attr(ggmap, 
                "bb")[, c("ll.lon", "ur.lon")]), lat = as.numeric(attr(ggmap, 
                "bb")[, c("ll.lat", "ur.lat")]))
            xmin <- attr(ggmap, "bb")$ll.lon
            xmax <- attr(ggmap, "bb")$ur.lon
            ymin <- attr(ggmap, "bb")$ll.lat
            ymax <- attr(ggmap, "bb")$ur.lat
            p <- ggplot(aes(x = lon, y = lat), data = fourCorners) + 
                geom_blank() + inset_raster(ggmap, xmin, xmax, 
                ymin, ymax) + annotate("rect", xmin = xmin, xmax = xmax, 
                ymin = ymin, ymax = ymax, fill = darken[2], alpha = as.numeric(darken[1]))
        }
        else {
            p <- ggplot() + geom_tile(aes(x = lon, y = lat, fill = fill), 
                data = ggmap) + scale_fill_identity(guide = "none")
            .Deprecated(msg = "geom_tile method is deprecated, use rasters.")
        }
    }
    else {
        stopifnot(inherits(ggmap, "raster"))
        args <- as.list(match.call()[-1])
        base <- deparse(args$base_layer)
        if (base[1] == "base_layer") 
            base <- deparse(eval(args$base_layer))
        xmin <- attr(ggmap, "bb")$ll.lon
        xmax <- attr(ggmap, "bb")$ur.lon
        ymin <- attr(ggmap, "bb")$ll.lat
        ymax <- attr(ggmap, "bb")$ur.lat
        str2parse <- paste(paste(base, collapse = ""), "geom_blank()", 
            "inset_raster(ggmap, xmin, xmax, ymin, ymax)", sep = " + ")
        p <- try(eval(parse(text = paste(base, collapse = "")), 
            parent.frame(1)) + geom_blank() + inset_raster(ggmap, 
            xmin, xmax, ymin, ymax))
        if (inherits(p, "try-error")) 
            p <- eval(parse(text = str2parse))
        p <- p + annotate("rect", xmin = xmin, xmax = xmax, ymin = ymin, 
            ymax = ymax, fill = darken[2], alpha = as.numeric(darken[1]))
    }
    if (maprange) 
        p <- p + xlim(xmin, xmax) + ylim(ymin, ymax)
    p <- p + coord_map2()
    xmin <- attr(ggmap, "bb")$ll.lon
    xmax <- attr(ggmap, "bb")$ur.lon
    ymin <- attr(ggmap, "bb")$ll.lat
    ymax <- attr(ggmap, "bb")$ur.lat
    if (extent == "normal") {
    }
    else if (extent == "panel") {
        p <- p + scale_x_continuous(limits = c(xmin, xmax), expand = c(0, 
            0)) + scale_y_continuous(limits = c(ymin, ymax), 
            expand = c(0, 0))
    }
    else if (extent == "device") {
        p <- p + scale_x_continuous(limits = c(xmin, xmax), expand = c(0, 
            0)) + scale_y_continuous(limits = c(ymin, ymax), 
            expand = c(0, 0)) + theme_nothing(legend = TRUE)
        if (legend %in% c("topleft", "topright", "bottomleft", 
            "bottomright")) {
            if (legend == "bottomleft") {
                lp <- c(padding, padding)
                lj <- c(0, 0)
            }
            else if (legend == "topleft") {
                lp <- c(padding, 1 - padding)
                lj <- c(0, 1)
            }
            else if (legend == "bottomright") {
                lp <- c(1 - padding, padding)
                lj <- c(1, 0)
            }
            else if (legend == "topright") {
                lp <- c(1 - padding, 1 - padding)
                lj <- c(1, 1)
            }
            p <- p + theme(legend.position = lp, legend.justification = lj, 
                legend.background = element_rect(fill = "white", 
                  colour = "gray80", size = 0.2))
        }
        else if (legend %in% c("left", "right", "bottom", "top")) {
            p <- p + theme(legend.position = legend)
        }
    }
    p
}
<bytecode: 0x15a25388>
<environment: namespace:ggmap>
 --- function search by body ---
Function ggmap in namespace ggmap has this body.
 ----------- END OF FAILURE REPORT -------------- 
Fatal error: length > 1 in coercion to logical

* checking PDF version of manual ... OK
* checking for non-standard things in the check directory ... OK
* checking for detritus in the temp directory ... OK
* DONE

Status: 1 ERROR
See
  ‘/data/gannet/ripley/R/packages/tests-LENGTH1/ggvoronoi.Rcheck/00check.log’
for details.

Command exited with non-zero status 1
Time 8:18.42, 338.38 + 20.57