CRAN Package Check Results for Package shadow

Last updated on 2020-01-17 22:51:05 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.6.3 8.73 102.81 111.54 ERROR
r-devel-linux-x86_64-debian-gcc 0.6.3 8.90 97.09 105.99 OK
r-devel-linux-x86_64-fedora-clang 0.6.3 160.55 NOTE
r-devel-linux-x86_64-fedora-gcc 0.6.3 158.55 NOTE
r-devel-windows-ix86+x86_64 0.6.3 27.00 178.00 205.00 OK
r-devel-windows-ix86+x86_64-gcc8 0.6.3 19.00 178.00 197.00 OK
r-patched-linux-x86_64 0.6.3 8.27 110.69 118.96 OK
r-patched-solaris-x86 0.6.3 194.80 NOTE
r-release-linux-x86_64 0.6.3 7.99 110.34 118.33 OK
r-release-windows-ix86+x86_64 0.6.3 27.00 125.00 152.00 OK
r-release-osx-x86_64 0.6.3 NOTE
r-oldrel-windows-ix86+x86_64 0.6.3 18.00 121.00 139.00 OK
r-oldrel-osx-x86_64 0.6.3 NOTE

Check Details

Version: 0.6.3
Check: examples
Result: ERROR
    Running examples in 'shadow-Ex.R' failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: inShadow
    > ### Title: Logical shadow calculation (is given point shaded?) for 3D
    > ### points considering sun position and obstacles
    > ### Aliases: inShadow inShadow,SpatialPoints,Raster,missing,missing-method
    > ### inShadow,SpatialPoints,missing,ANY,ANY-method
    > ### inShadow,Raster,missing,ANY,ANY-method
    >
    > ### ** Examples
    >
    > # Method for 3D points - Manually defined
    >
    > opar = par(mfrow = c(1, 3))
    >
    > # Ground level
    > location = sp::spsample(
    + rgeos::gBuffer(rgeos::gEnvelope(build), width = 20),
    + n = 100,
    + type = "regular"
    + )
    > solar_pos = as.matrix(tmy[9, c("sun_az", "sun_elev")])
    > s = inShadow(
    + location = location,
    + obstacles = build,
    + obstacles_height_field = "BLDG_HT",
    + solar_pos = solar_pos
    + )
    
     |
     | | 0% ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
    :
     --- package (from environment) ---
    shadow
     --- call from context ---
    .checkSolarPos(solar_pos, length1 = FALSE)
     --- call from argument ---
    if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object")
     --- R stacktrace ---
    where 1: .checkSolarPos(solar_pos, length1 = FALSE)
    where 2: .local(location, obstacles, obstacles_height_field, ...)
    where 3: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
    where 4: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
    where 5: .local(location, shadowHeightRaster = shadowHeightRaster, obstacles = obstacles,
     obstacles_height_field = obstacles_height_field, ...)
    where 6: inShadow(location = location, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
    where 7: inShadow(location = location, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
    
     --- value of length: 2 type: logical ---
    [1] FALSE TRUE
     --- function from context ---
    function (solar_pos, length1)
    {
     if (class(solar_pos) != "matrix")
     stop("'solar_pos' must be a 'matrix' object")
     if (length1 & nrow(solar_pos) > 1)
     stop("'solar_pos' must have a single row (sun position)")
     if (ncol(solar_pos) != 2)
     stop("'solar_pos' must have two columns (azimuth + elevation)")
     if (any(solar_pos[, 1] < 0) | any(solar_pos[, 1] > 360))
     stop("Sun azimuth should be a number in [0, 360]")
     if (any(solar_pos[, 2] < -90) | any(solar_pos[, 2] > 90))
     stop("Sun elevation should be a number in [-90, 90]")
    }
    <bytecode: 0x57fd578>
    <environment: namespace:shadow>
     --- function search by body ---
    Function .checkSolarPos in namespace shadow has this body.
     ----------- END OF FAILURE REPORT --------------
    Error in if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object") :
     the condition has length > 1
    Calls: inShadow ... shadowHeight -> shadowHeight -> .local -> .checkSolarPos
    Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.6.3
Check: tests
Result: ERROR
     Running 'testthat.R' [12s/13s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(shadow)
     Loading required package: sp
     >
     > test_check("shadow")
    
     |
     | | 0% ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     shadow
     --- call from context ---
     .checkSolarPos(solar_pos, length1 = FALSE)
     --- call from argument ---
     if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object")
     --- R stacktrace ---
     where 1: .checkSolarPos(solar_pos, length1 = FALSE)
     where 2: .local(location, obstacles, obstacles_height_field, ...)
     where 3: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
     where 4: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
     where 5: .local(location, shadowHeightRaster = shadowHeightRaster, obstacles = obstacles,
     obstacles_height_field = obstacles_height_field, ...)
     where 6: inShadow(location = location, obstacles = obstacles, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 7 at testthat/test_inShadow.R#753: inShadow(location = location, obstacles = obstacles, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 8: eval_bare(expr, quo_get_env(quo))
     where 9: quasi_label(enquo(object), label, arg = "object")
     where 10 at testthat/test_inShadow.R#6: expect_equal({
     obstacles = build[c(2, 4), ]
     location = new("SpatialPointsDataFrame", data = structure(list(type = c("roof",
     "roof", "roof", "roof", "roof", "roof", "roof", "roof",
     "roof", "roof", "roof", "roof", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade", "facade",
     "facade"), seg_id = c(NA, NA, NA, NA, NA, NA, NA, NA,
     NA, NA, NA, NA, 1L, 4L, 5L, 9L, 10L, 11L, 14L, 16L, 18L,
     18L, 1L, 4L, 5L, 9L, 10L, 11L, 14L, 16L, 18L, 18L, 20L,
     23L, 24L, 28L, 31L, 32L, 35L, 36L, 37L, 38L, 20L, 23L,
     24L, 28L, 31L, 32L, 35L, 36L, 37L, 38L), xy_id = c(NA,
     NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 1L, 2L, 3L,
     4L, 5L, 6L, 7L, 8L, 9L, 10L, 1L, 2L, 3L, 4L, 5L, 6L,
     7L, 8L, 9L, 10L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L,
     10L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L), facade_az = c(NA,
     NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 226.322278325374,
     152.204221415427, 242.13181892178, 316.200889778535,
     333.421572287427, 24.9752762360012, 328.380934845646,
     105.531965883941, 139.567326407853, 139.567326407853,
     226.322278325374, 152.204221415427, 242.13181892178,
     316.200889778535, 333.421572287427, 24.9752762360012,
     328.380934845646, 105.531965883941, 139.567326407853,
     139.567326407853, 271.123328059388, 205.585315811037,
     213.10385755862, 290.634122877769, 342.073067198459,
     60.2107838686251, 5.76532673402092, 84.2807089696567,
     100.265022941512, 123.669503648238, 271.123328059388,
     205.585315811037, 213.10385755862, 290.634122877769,
     342.073067198459, 60.2107838686251, 5.76532673402092,
     84.2807089696567, 100.265022941512, 123.669503648238),
     build_id = c("365", "365", "365", "365", "365", "365",
     "831", "831", "831", "831", "831", "831", "365",
     "365", "365", "365", "365", "365", "365", "365",
     "365", "365", "365", "365", "365", "365", "365",
     "365", "365", "365", "365", "365", "831", "831",
     "831", "831", "831", "831", "831", "831", "831",
     "831", "831", "831", "831", "831", "831", "831",
     "831", "831", "831", "831"), BLDG_HT = c(22.73, 22.73,
     22.73, 22.73, 22.73, 22.73, 19.07, 19.07, 19.07,
     19.07, 19.07, 19.07, 22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 22.73, 22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 22.73, 22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07, 19.07, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07, 19.07, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07), obs_id = c(1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L,
     2L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,
     1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L,
     2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L,
     2L, 2L, 2L, 2L, 2L), height = c(22.74, 22.74, 22.74,
     22.74, 22.74, 22.74, 19.08, 19.08, 19.08, 19.08,
     19.08, 19.08, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15, 5, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15)),
     .Names = c("type", "seg_id", "xy_id", "facade_az", "build_id",
     "BLDG_HT", "obs_id", "height"), row.names = c("1",
     "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
     "12", "110", "21", "31", "41", "51", "61", "71",
     "81", "91", "101", "113", "123", "13", "14", "15",
     "16", "17", "18", "19", "20", "111", "121", "131",
     "141", "151", "161", "171", "181", "191", "201",
     "112", "122", "132", "142", "152", "162", "172",
     "182", "192", "202"), class = "data.frame"), coords.nrs = numeric(0),
     coords = structure(c(667907.571939006, 667917.571939006,
     667927.571939006, 667907.571939006, 667917.571939006,
     667927.571939006, 667917.571939006, 667927.571939006,
     667937.571939006, 667917.571939006, 667927.571939006,
     667937.571939006, 667911.182321722, 667908.81713281,
     667903.060000456, 667905.663089928, 667913.16502473,
     667922.043864029, 667926.38072157, 667931.776158766,
     667925.610747157, 667918.149139333, 667911.182321722,
     667908.81713281, 667903.060000456, 667905.663089928,
     667913.16502473, 667922.043864029, 667926.38072157,
     667931.776158766, 667925.610747157, 667918.149139333,
     667928.623157747, 667922.31034574, 667913.74513528,
     667913.127173768, 667918.514590853, 667926.683035748,
     667934.16216899, 667940.381465392, 667940.738830277,
     667936.216743819, 667928.623157747, 667922.31034574,
     667913.74513528, 667913.127173768, 667918.514590853,
     667926.683035748, 667934.16216899, 667940.381465392,
     667940.738830277, 667936.216743819, 3538103.22116346,
     3538103.22116346, 3538103.22116346, 3538113.22116346,
     3538113.22116346, 3538113.22116346, 3538123.22116346,
     3538123.22116346, 3538123.22116346, 3538133.22116346,
     3538133.22116346, 3538133.22116346, 3538097.58769166,
     3538103.73369686, 3538108.64450593, 3538115.96441413,
     3538122.14955971, 3538119.15618478, 3538114.0389939,
     3538107.73779458, 3538100.4172045, 3538094.05953785,
     3538097.58769166, 3538103.73369686, 3538108.64450593,
     3538115.96441413, 3538122.14955971, 3538119.15618478,
     3538114.0389939, 3538107.73779458, 3538100.4172045,
     3538094.05953785, 3538119.68057611, 3538120.57495039,
     3538125.22656349, 3538134.67137422, 3538140.85043566,
     3538140.91758237, 3538141.47221756, 3538136.97937816,
     3538127.28418104, 3538118.79274352, 3538119.68057611,
     3538120.57495039, 3538125.22656349, 3538134.67137422,
     3538140.85043566, 3538140.91758237, 3538141.47221756,
     3538136.97937816, 3538127.28418104, 3538118.79274352,
     22.74, 22.74, 22.74, 22.74, 22.74, 22.74, 19.08,
     19.08, 19.08, 19.08, 19.08, 19.08, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 5, 15, 15, 15, 15, 15, 15, 15, 15, 15,
     15, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 15), .Dim = c(52L, 3L), .Dimnames = list(c("1",
     "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
     "12", "110", "21", "31", "41", "51", "61", "71",
     "81", "91", "101", "113", "123", "13", "14", "15",
     "16", "17", "18", "19", "20", "111", "121", "131",
     "141", "151", "161", "171", "181", "191", "201",
     "112", "122", "132", "142", "152", "162", "172",
     "182", "192", "202"), c("x1", "x2", "h"))), bbox = structure(c(667903.060000456,
     3538094.05953785, 5, 667940.738830277, 3538141.47221756,
     22.74), .Dim = c(3L, 2L), .Dimnames = list(c("x1",
     "x2", "h"), c("min", "max"))), proj4string = new("CRS",
     projargs = "+proj=utm +zone=36 +datum=WGS84 +units=m +no_defs +ellps=WGS84 +towgs84=0,0,0"))
     solar_pos = tmy[c(9, 16), c("sun_az", "sun_elev")]
     solar_pos = as.matrix(solar_pos)
     s = inShadow(location = location, obstacles = obstacles,
     obstacles_height_field = "BLDG_HT", solar_pos = solar_pos)
     }, structure(c(FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,
     FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE,
     TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE,
     TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE,
     FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE,
     FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE,
     TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE), .Dim = c(52L, 2L)))
     where 11: eval(code, test_env)
     where 12: eval(code, test_env)
     where 13: 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 14: doTryCatch(return(expr), name, parentenv, handler)
     where 15: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 16: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 19: tryCatchList(expr, classes, parentenv, handlers)
     where 20: 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 21: test_code(desc, code, env = parent.frame())
     where 22 at testthat/test_inShadow.R#5: test_that("'inShadow' calculation is correct", {
     expect_equal({
     obstacles = build[c(2, 4), ]
     location = new("SpatialPointsDataFrame", data = structure(list(type = c("roof",
     "roof", "roof", "roof", "roof", "roof", "roof", "roof",
     "roof", "roof", "roof", "roof", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade", "facade", "facade",
     "facade", "facade", "facade"), seg_id = c(NA, NA,
     NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 1L, 4L, 5L,
     9L, 10L, 11L, 14L, 16L, 18L, 18L, 1L, 4L, 5L, 9L,
     10L, 11L, 14L, 16L, 18L, 18L, 20L, 23L, 24L, 28L,
     31L, 32L, 35L, 36L, 37L, 38L, 20L, 23L, 24L, 28L,
     31L, 32L, 35L, 36L, 37L, 38L), xy_id = c(NA, NA,
     NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, 1L, 2L, 3L,
     4L, 5L, 6L, 7L, 8L, 9L, 10L, 1L, 2L, 3L, 4L, 5L,
     6L, 7L, 8L, 9L, 10L, 1L, 2L, 3L, 4L, 5L, 6L, 7L,
     8L, 9L, 10L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L,
     10L), facade_az = c(NA, NA, NA, NA, NA, NA, NA, NA,
     NA, NA, NA, NA, 226.322278325374, 152.204221415427,
     242.13181892178, 316.200889778535, 333.421572287427,
     24.9752762360012, 328.380934845646, 105.531965883941,
     139.567326407853, 139.567326407853, 226.322278325374,
     152.204221415427, 242.13181892178, 316.200889778535,
     333.421572287427, 24.9752762360012, 328.380934845646,
     105.531965883941, 139.567326407853, 139.567326407853,
     271.123328059388, 205.585315811037, 213.10385755862,
     290.634122877769, 342.073067198459, 60.2107838686251,
     5.76532673402092, 84.2807089696567, 100.265022941512,
     123.669503648238, 271.123328059388, 205.585315811037,
     213.10385755862, 290.634122877769, 342.073067198459,
     60.2107838686251, 5.76532673402092, 84.2807089696567,
     100.265022941512, 123.669503648238), build_id = c("365",
     "365", "365", "365", "365", "365", "831", "831",
     "831", "831", "831", "831", "365", "365", "365",
     "365", "365", "365", "365", "365", "365", "365",
     "365", "365", "365", "365", "365", "365", "365",
     "365", "365", "365", "831", "831", "831", "831",
     "831", "831", "831", "831", "831", "831", "831",
     "831", "831", "831", "831", "831", "831", "831",
     "831", "831"), BLDG_HT = c(22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07, 22.73, 22.73, 22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 22.73, 22.73, 22.73, 22.73, 22.73,
     22.73, 22.73, 22.73, 22.73, 22.73, 22.73, 22.73,
     19.07, 19.07, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07, 19.07, 19.07, 19.07, 19.07, 19.07, 19.07,
     19.07, 19.07, 19.07, 19.07, 19.07, 19.07), obs_id = c(1L,
     1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 1L, 1L,
     1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L,
     1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L,
     2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L),
     height = c(22.74, 22.74, 22.74, 22.74, 22.74, 22.74,
     19.08, 19.08, 19.08, 19.08, 19.08, 19.08, 5,
     5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 15, 15, 15, 15,
     15, 15, 15, 15, 15, 5, 5, 5, 5, 5, 5, 5, 5, 5,
     5, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15)),
     .Names = c("type", "seg_id", "xy_id", "facade_az",
     "build_id", "BLDG_HT", "obs_id", "height"), row.names = c("1",
     "2", "3", "4", "5", "6", "7", "8", "9", "10",
     "11", "12", "110", "21", "31", "41", "51", "61",
     "71", "81", "91", "101", "113", "123", "13",
     "14", "15", "16", "17", "18", "19", "20", "111",
     "121", "131", "141", "151", "161", "171", "181",
     "191", "201", "112", "122", "132", "142", "152",
     "162", "172", "182", "192", "202"), class = "data.frame"),
     coords.nrs = numeric(0), coords = structure(c(667907.571939006,
     667917.571939006, 667927.571939006, 667907.571939006,
     667917.571939006, 667927.571939006, 667917.571939006,
     667927.571939006, 667937.571939006, 667917.571939006,
     667927.571939006, 667937.571939006, 667911.182321722,
     667908.81713281, 667903.060000456, 667905.663089928,
     667913.16502473, 667922.043864029, 667926.38072157,
     667931.776158766, 667925.610747157, 667918.149139333,
     667911.182321722, 667908.81713281, 667903.060000456,
     667905.663089928, 667913.16502473, 667922.043864029,
     667926.38072157, 667931.776158766, 667925.610747157,
     667918.149139333, 667928.623157747, 667922.31034574,
     667913.74513528, 667913.127173768, 667918.514590853,
     667926.683035748, 667934.16216899, 667940.381465392,
     667940.738830277, 667936.216743819, 667928.623157747,
     667922.31034574, 667913.74513528, 667913.127173768,
     667918.514590853, 667926.683035748, 667934.16216899,
     667940.381465392, 667940.738830277, 667936.216743819,
     3538103.22116346, 3538103.22116346, 3538103.22116346,
     3538113.22116346, 3538113.22116346, 3538113.22116346,
     3538123.22116346, 3538123.22116346, 3538123.22116346,
     3538133.22116346, 3538133.22116346, 3538133.22116346,
     3538097.58769166, 3538103.73369686, 3538108.64450593,
     3538115.96441413, 3538122.14955971, 3538119.15618478,
     3538114.0389939, 3538107.73779458, 3538100.4172045,
     3538094.05953785, 3538097.58769166, 3538103.73369686,
     3538108.64450593, 3538115.96441413, 3538122.14955971,
     3538119.15618478, 3538114.0389939, 3538107.73779458,
     3538100.4172045, 3538094.05953785, 3538119.68057611,
     3538120.57495039, 3538125.22656349, 3538134.67137422,
     3538140.85043566, 3538140.91758237, 3538141.47221756,
     3538136.97937816, 3538127.28418104, 3538118.79274352,
     3538119.68057611, 3538120.57495039, 3538125.22656349,
     3538134.67137422, 3538140.85043566, 3538140.91758237,
     3538141.47221756, 3538136.97937816, 3538127.28418104,
     3538118.79274352, 22.74, 22.74, 22.74, 22.74,
     22.74, 22.74, 19.08, 19.08, 19.08, 19.08, 19.08,
     19.08, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 15, 15,
     15, 15, 15, 15, 15, 15, 15, 15, 5, 5, 5, 5, 5,
     5, 5, 5, 5, 5, 15, 15, 15, 15, 15, 15, 15, 15,
     15, 15), .Dim = c(52L, 3L), .Dimnames = list(c("1",
     "2", "3", "4", "5", "6", "7", "8", "9", "10",
     "11", "12", "110", "21", "31", "41", "51", "61",
     "71", "81", "91", "101", "113", "123", "13",
     "14", "15", "16", "17", "18", "19", "20", "111",
     "121", "131", "141", "151", "161", "171", "181",
     "191", "201", "112", "122", "132", "142", "152",
     "162", "172", "182", "192", "202"), c("x1", "x2",
     "h"))), bbox = structure(c(667903.060000456,
     3538094.05953785, 5, 667940.738830277, 3538141.47221756,
     22.74), .Dim = c(3L, 2L), .Dimnames = list(c("x1",
     "x2", "h"), c("min", "max"))), proj4string = new("CRS",
     projargs = "+proj=utm +zone=36 +datum=WGS84 +units=m +no_defs +ellps=WGS84 +towgs84=0,0,0"))
     solar_pos = tmy[c(9, 16), c("sun_az", "sun_elev")]
     solar_pos = as.matrix(solar_pos)
     s = inShadow(location = location, obstacles = obstacles,
     obstacles_height_field = "BLDG_HT", solar_pos = solar_pos)
     }, structure(c(FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
     TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE,
     TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE,
     TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE,
     TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE,
     FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE,
     FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE,
     TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE,
     FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE,
     FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
     TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE,
     TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE,
     TRUE), .Dim = c(52L, 2L)))
     })
     where 23: eval(code, test_env)
     where 24: eval(code, test_env)
     where 25: 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 26: doTryCatch(return(expr), name, parentenv, handler)
     where 27: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 28: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 29: doTryCatch(return(expr), name, parentenv, handler)
     where 30: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 31: tryCatchList(expr, classes, parentenv, handlers)
     where 32: 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 33: test_code(NULL, exprs, env)
     where 34: source_file(path, new.env(parent = env), chdir = TRUE, 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 = 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 40: FUN(X[[i]], ...)
     where 41: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 42: force(code)
     where 43: doWithOneRestart(return(expr), restart)
     where 44: withOneRestart(expr, restarts[[1L]])
     where 45: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 46: 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 47: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 48: 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 49: 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 50: test_check("shadow")
    
     --- value of length: 2 type: logical ---
     [1] FALSE TRUE
     --- function from context ---
     function (solar_pos, length1)
     {
     if (class(solar_pos) != "matrix")
     stop("'solar_pos' must be a 'matrix' object")
     if (length1 & nrow(solar_pos) > 1)
     stop("'solar_pos' must have a single row (sun position)")
     if (ncol(solar_pos) != 2)
     stop("'solar_pos' must have two columns (azimuth + elevation)")
     if (any(solar_pos[, 1] < 0) | any(solar_pos[, 1] > 360))
     stop("Sun azimuth should be a number in [0, 360]")
     if (any(solar_pos[, 2] < -90) | any(solar_pos[, 2] > 90))
     stop("Sun elevation should be a number in [-90, 90]")
     }
     <bytecode: 0x971a498>
     <environment: namespace:shadow>
     --- function search by body ---
     Function .checkSolarPos in namespace shadow has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 1. Error: 'inShadow' calculation is correct (@test_inShadow.R#6) -----------
     the condition has length > 1
     Backtrace:
     1. testthat::expect_equal(...)
     5. shadow::inShadow(...)
     6. shadow:::.local(...)
     8. shadow::shadowHeight(...)
     9. shadow:::.local(...)
     10. shadow:::.checkSolarPos(solar_pos, length1 = FALSE)
    
     Determining Shadow
    
     |
     | | 0% ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     shadow
     --- call from context ---
     .checkSolarPos(solar_pos, length1 = FALSE)
     --- call from argument ---
     if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object")
     --- R stacktrace ---
     where 1: .checkSolarPos(solar_pos, length1 = FALSE)
     where 2: .local(location, obstacles, obstacles_height_field, ...)
     where 3: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
     where 4: shadowHeight(location = pnt_unique, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos[col, , drop = FALSE], ...)
     where 5: .local(location, shadowHeightRaster = shadowHeightRaster, obstacles = obstacles,
     obstacles_height_field = obstacles_height_field, ...)
     where 6: inShadow(location = grid, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos, parallel = parallel)
     where 7: inShadow(location = grid, obstacles = obstacles, obstacles_height_field = obstacles_height_field,
     solar_pos = solar_pos, parallel = parallel)
     where 8: .radiationGrid(grid, obstacles, obstacles_height_field, solar_pos,
     solar_normal, solar_diffuse, returnList, parallel)
     where 9 at testthat/test_radiation.R#77: radiation(grid = grid, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos[8:17, , drop = FALSE], solar_normal = tmy$solar_normal[8:17],
     solar_diffuse = tmy$solar_diffuse[8:17])
     where 10: eval_bare(expr, quo_get_env(quo))
     where 11: quasi_label(enquo(object), label, arg = "object")
     where 12 at testthat/test_radiation.R#6: expect_equal({
     data(build)
     data(tmy)
     set.seed(17)
     grid = new("SpatialPointsDataFrame", data = structure(list(build_id = c("407",
     "407", "407"), BLDG_HT = c(21.38, 21.38, 21.38), obs_id = c(1L,
     1L, 1L), type = c("facade", "roof", "facade"), seg_id = c(6L,
     NA, 21L), xy_id = c(18L, NA, 50L), facade_az = c(321.427363755109,
     NA, 136.951204869441)), .Names = c("build_id", "BLDG_HT",
     "obs_id", "type", "seg_id", "xy_id", "facade_az"), row.names = c(400L,
     15L, 687L), class = "data.frame"), coords.nrs = numeric(0),
     coords = structure(c(667855.102115946, 667862.288856074,
     667871.369943073, 3538112.62815535, 3538101.47268511,
     3538095.63665798, 11, 21.39, 21), .Dim = c(3L, 3L),
     .Dimnames = list(NULL, c("x1", "x2", "h"))), bbox = structure(c(667855.102115946,
     3538095.63665798, 11, 667871.369943073, 3538112.62815535,
     21.39), .Dim = c(3L, 2L), .Dimnames = list(c("x1",
     "x2", "h"), c("min", "max"))), proj4string = new("CRS",
     projargs = "+proj=utm +zone=36 +datum=WGS84 +units=m +no_defs +ellps=WGS84 +towgs84=0,0,0"))
     solar_pos = tmy[, c("sun_az", "sun_elev")]
     solar_pos = as.matrix(solar_pos)
     radiation(grid = grid, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos[8:17, , drop = FALSE], solar_normal = tmy$solar_normal[8:17],
     solar_diffuse = tmy$solar_diffuse[8:17])
     }, structure(list(svf = c(0.484475008535678, 0.998328963274761,
     0.491760588247644), direct = c(21.0822885075299, 2755.36321510678,
     2913.69184551694), diffuse = c(250.473579412946, 516.136074013052,
     254.240224124032), total = c(271.555867920476, 3271.49928911984,
     3167.93206964097)), .Names = c("svf", "direct", "diffuse",
     "total"), row.names = c(NA, -3L), class = "data.frame"))
     where 13: eval(code, test_env)
     where 14: eval(code, test_env)
     where 15: 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 16: doTryCatch(return(expr), name, parentenv, handler)
     where 17: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 18: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 19: doTryCatch(return(expr), name, parentenv, handler)
     where 20: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 21: tryCatchList(expr, classes, parentenv, handlers)
     where 22: 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 23: test_code(desc, code, env = parent.frame())
     where 24 at testthat/test_radiation.R#5: test_that("radiation calculation is correct", {
     expect_equal({
     data(build)
     data(tmy)
     set.seed(17)
     grid = new("SpatialPointsDataFrame", data = structure(list(build_id = c("407",
     "407", "407"), BLDG_HT = c(21.38, 21.38, 21.38),
     obs_id = c(1L, 1L, 1L), type = c("facade", "roof",
     "facade"), seg_id = c(6L, NA, 21L), xy_id = c(18L,
     NA, 50L), facade_az = c(321.427363755109, NA,
     136.951204869441)), .Names = c("build_id", "BLDG_HT",
     "obs_id", "type", "seg_id", "xy_id", "facade_az"),
     row.names = c(400L, 15L, 687L), class = "data.frame"),
     coords.nrs = numeric(0), coords = structure(c(667855.102115946,
     667862.288856074, 667871.369943073, 3538112.62815535,
     3538101.47268511, 3538095.63665798, 11, 21.39,
     21), .Dim = c(3L, 3L), .Dimnames = list(NULL,
     c("x1", "x2", "h"))), bbox = structure(c(667855.102115946,
     3538095.63665798, 11, 667871.369943073, 3538112.62815535,
     21.39), .Dim = c(3L, 2L), .Dimnames = list(c("x1",
     "x2", "h"), c("min", "max"))), proj4string = new("CRS",
     projargs = "+proj=utm +zone=36 +datum=WGS84 +units=m +no_defs +ellps=WGS84 +towgs84=0,0,0"))
     solar_pos = tmy[, c("sun_az", "sun_elev")]
     solar_pos = as.matrix(solar_pos)
     radiation(grid = grid, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos[8:17, , drop = FALSE], solar_normal = tmy$solar_normal[8:17],
     solar_diffuse = tmy$solar_diffuse[8:17])
     }, structure(list(svf = c(0.484475008535678, 0.998328963274761,
     0.491760588247644), direct = c(21.0822885075299, 2755.36321510678,
     2913.69184551694), diffuse = c(250.473579412946, 516.136074013052,
     254.240224124032), total = c(271.555867920476, 3271.49928911984,
     3167.93206964097)), .Names = c("svf", "direct", "diffuse",
     "total"), row.names = c(NA, -3L), class = "data.frame"))
     })
     where 25: eval(code, test_env)
     where 26: eval(code, test_env)
     where 27: 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 28: doTryCatch(return(expr), name, parentenv, handler)
     where 29: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 30: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 31: doTryCatch(return(expr), name, parentenv, handler)
     where 32: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 33: tryCatchList(expr, classes, parentenv, handlers)
     where 34: 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 35: test_code(NULL, exprs, env)
     where 36: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 37: force(code)
     where 38: doWithOneRestart(return(expr), restart)
     where 39: withOneRestart(expr, restarts[[1L]])
     where 40: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 41: 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 42: FUN(X[[i]], ...)
     where 43: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 44: force(code)
     where 45: doWithOneRestart(return(expr), restart)
     where 46: withOneRestart(expr, restarts[[1L]])
     where 47: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 48: 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 49: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 50: 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 51: 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 52: test_check("shadow")
    
     --- value of length: 2 type: logical ---
     [1] FALSE TRUE
     --- function from context ---
     function (solar_pos, length1)
     {
     if (class(solar_pos) != "matrix")
     stop("'solar_pos' must be a 'matrix' object")
     if (length1 & nrow(solar_pos) > 1)
     stop("'solar_pos' must have a single row (sun position)")
     if (ncol(solar_pos) != 2)
     stop("'solar_pos' must have two columns (azimuth + elevation)")
     if (any(solar_pos[, 1] < 0) | any(solar_pos[, 1] > 360))
     stop("Sun azimuth should be a number in [0, 360]")
     if (any(solar_pos[, 2] < -90) | any(solar_pos[, 2] > 90))
     stop("Sun elevation should be a number in [-90, 90]")
     }
     <bytecode: 0x971a498>
     <environment: namespace:shadow>
     --- function search by body ---
     Function .checkSolarPos in namespace shadow has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 2. Error: radiation calculation is correct (@test_radiation.R#6) -----------
     the condition has length > 1
     Backtrace:
     1. testthat::expect_equal(...)
     4. shadow::radiation(...)
     5. shadow:::.radiationGrid(...)
     7. shadow::inShadow(...)
     8. shadow:::.local(...)
     10. shadow::shadowHeight(...)
     11. shadow:::.local(...)
     12. shadow:::.checkSolarPos(solar_pos, length1 = FALSE)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     shadow
     --- call from context ---
     .checkSolarPos(solar_pos, length1 = TRUE)
     --- call from argument ---
     if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object")
     --- R stacktrace ---
     where 1: .checkSolarPos(solar_pos, length1 = TRUE)
     where 2: .local(obstacles, obstacles_height_field, ...)
     where 3: shadowFootprint(obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 4 at testthat/test_shadowFootprint.R#14: shadowFootprint(obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 5: eval_bare(expr, quo_get_env(quo))
     where 6: quasi_label(enquo(object), label, arg = "object")
     where 7 at testthat/test_shadowFootprint.R#6: expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     time = as.POSIXct("2004-12-24 13:30:00", tz = "Asia/Jerusalem")
     solar_pos = maptools::solarpos(matrix(c(34.7767978098526,
     31.9665936050395), ncol = 2), time)
     footprint = shadowFootprint(obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     rgeos::gArea(footprint)
     }, 6513.44739346873)
     where 8: eval(code, test_env)
     where 9: eval(code, test_env)
     where 10: 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 11: doTryCatch(return(expr), name, parentenv, handler)
     where 12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 13: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 14: doTryCatch(return(expr), name, parentenv, handler)
     where 15: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 16: tryCatchList(expr, classes, parentenv, handlers)
     where 17: 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 18: test_code(desc, code, env = parent.frame())
     where 19 at testthat/test_shadowFootprint.R#5: test_that("Shade footprint calculation is correct", {
     expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     time = as.POSIXct("2004-12-24 13:30:00", tz = "Asia/Jerusalem")
     solar_pos = maptools::solarpos(matrix(c(34.7767978098526,
     31.9665936050395), ncol = 2), time)
     footprint = shadowFootprint(obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     rgeos::gArea(footprint)
     }, 6513.44739346873)
     })
     where 20: eval(code, test_env)
     where 21: eval(code, test_env)
     where 22: 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 23: doTryCatch(return(expr), name, parentenv, handler)
     where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 25: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 26: doTryCatch(return(expr), name, parentenv, handler)
     where 27: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 28: tryCatchList(expr, classes, parentenv, handlers)
     where 29: 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 30: test_code(NULL, exprs, env)
     where 31: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 32: force(code)
     where 33: doWithOneRestart(return(expr), restart)
     where 34: withOneRestart(expr, restarts[[1L]])
     where 35: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 36: 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 37: FUN(X[[i]], ...)
     where 38: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 39: force(code)
     where 40: doWithOneRestart(return(expr), restart)
     where 41: withOneRestart(expr, restarts[[1L]])
     where 42: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 43: 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 44: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 45: 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 46: 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 47: test_check("shadow")
    
     --- value of length: 2 type: logical ---
     [1] FALSE TRUE
     --- function from context ---
     function (solar_pos, length1)
     {
     if (class(solar_pos) != "matrix")
     stop("'solar_pos' must be a 'matrix' object")
     if (length1 & nrow(solar_pos) > 1)
     stop("'solar_pos' must have a single row (sun position)")
     if (ncol(solar_pos) != 2)
     stop("'solar_pos' must have two columns (azimuth + elevation)")
     if (any(solar_pos[, 1] < 0) | any(solar_pos[, 1] > 360))
     stop("Sun azimuth should be a number in [0, 360]")
     if (any(solar_pos[, 2] < -90) | any(solar_pos[, 2] > 90))
     stop("Sun elevation should be a number in [-90, 90]")
     }
     <bytecode: 0x971a498>
     <environment: namespace:shadow>
     --- function search by body ---
     Function .checkSolarPos in namespace shadow has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 3. Error: Shade footprint calculation is correct (@test_shadowFootprint.R#6)
     the condition has length > 1
     Backtrace:
     1. testthat::expect_equal(...)
     5. shadow::shadowFootprint(...)
     6. shadow:::.local(obstacles, obstacles_height_field, ...)
     7. shadow:::.checkSolarPos(solar_pos, length1 = TRUE)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     shadow
     --- call from context ---
     .checkSolarPos(solar_pos, length1 = FALSE)
     --- call from argument ---
     if (class(solar_pos) != "matrix") stop("'solar_pos' must be a 'matrix' object")
     --- R stacktrace ---
     where 1: .checkSolarPos(solar_pos, length1 = FALSE)
     where 2: .local(location, obstacles, obstacles_height_field, ...)
     where 3: shadowHeight(location = location, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 4 at testthat/test_shadowHeight.R#13: shadowHeight(location = location, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     where 5: eval_bare(expr, quo_get_env(quo))
     where 6: quasi_label(enquo(object), label, arg = "object")
     where 7 at testthat/test_shadowHeight.R#6: expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     solar_pos = matrix(c(208.733303840646, 241.006416412884,
     262.037856636259, 28.7994405393304, 1.81958332207186,
     -34.5606455413366), ncol = 2)
     shadowHeight(location = location, obstacles = build, obstacles_height_field = "BLDG_HT",
     solar_pos = solar_pos)
     }, matrix(c(19.8645079285858, 22.3721120166259, Inf), nrow = 1,
     ncol = 3))
     where 8: eval(code, test_env)
     where 9: eval(code, test_env)
     where 10: 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 11: doTryCatch(return(expr), name, parentenv, handler)
     where 12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 13: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 14: doTryCatch(return(expr), name, parentenv, handler)
     where 15: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 16: tryCatchList(expr, classes, parentenv, handlers)
     where 17: 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 18: test_code(desc, code, env = parent.frame())
     where 19 at testthat/test_shadowHeight.R#5: test_that("Shade height calculation is correct", {
     expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     solar_pos = matrix(c(208.733303840646, 241.006416412884,
     262.037856636259, 28.7994405393304, 1.81958332207186,
     -34.5606455413366), ncol = 2)
     shadowHeight(location = location, obstacles = build,
     obstacles_height_field = "BLDG_HT", solar_pos = solar_pos)
     }, matrix(c(19.8645079285858, 22.3721120166259, Inf), nrow = 1,
     ncol = 3))
     expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     solar_pos = matrix(c(343.665362102935, -81.0986528138936),
     ncol = 2)
     shadowHeight(location = location, obstacles = build,
     obstacles_height_field = "BLDG_HT", solar_pos = solar_pos)
     }, matrix(Inf, nrow = 1, ncol = 1))
     expect_equal({
     data(build)
     location = rgeos::gCentroid(build)
     solar_pos = matrix(c(0, 80), ncol = 2)
     shadowHeight(location = location, obstacles = build,
     obstacles_height_field = "BLDG_HT", solar_pos = solar_pos)
     }, matrix(NA, nrow = 1, ncol = 1))
     })
     where 20: eval(code, test_env)
     where 21: eval(code, test_env)
     where 22: 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 23: doTryCatch(return(expr), name, parentenv, handler)
     where 24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 25: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 26: doTryCatch(return(expr), name, parentenv, handler)
     where 27: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 28: tryCatchList(expr, classes, parentenv, handlers)
     where 29: 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 30: test_code(NULL, exprs, env)
     where 31: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 32: force(code)
     where 33: doWithOneRestart(return(expr), restart)
     where 34: withOneRestart(expr, restarts[[1L]])
     where 35: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 36: 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 37: FUN(X[[i]], ...)
     where 38: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 39: force(code)
     where 40: doWithOneRestart(return(expr), restart)
     where 41: withOneRestart(expr, restarts[[1L]])
     where 42: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 43: 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 44: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 45: 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 46: 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 47: test_check("shadow")
    
     --- value of length: 2 type: logical ---
     [1] FALSE TRUE
     --- function from context ---
     function (solar_pos, length1)
     {
     if (class(solar_pos) != "matrix")
     stop("'solar_pos' must be a 'matrix' object")
     if (length1 & nrow(solar_pos) > 1)
     stop("'solar_pos' must have a single row (sun position)")
     if (ncol(solar_pos) != 2)
     stop("'solar_pos' must have two columns (azimuth + elevation)")
     if (any(solar_pos[, 1] < 0) | any(solar_pos[, 1] > 360))
     stop("Sun azimuth should be a number in [0, 360]")
     if (any(solar_pos[, 2] < -90) | any(solar_pos[, 2] > 90))
     stop("Sun elevation should be a number in [-90, 90]")
     }
     <bytecode: 0x971a498>
     <environment: namespace:shadow>
     --- function search by body ---
     Function .checkSolarPos in namespace shadow has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 4. Error: Shade height calculation is correct (@test_shadowHeight.R#6) -----
     the condition has length > 1
     Backtrace:
     1. testthat::expect_equal(...)
     5. shadow::shadowHeight(...)
     6. shadow:::.local(...)
     7. shadow:::.checkSolarPos(solar_pos, length1 = FALSE)
    
     == testthat results ===========================================================
     [ OK: 3 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 4 ]
     1. Error: 'inShadow' calculation is correct (@test_inShadow.R#6)
     2. Error: radiation calculation is correct (@test_radiation.R#6)
     3. Error: Shade footprint calculation is correct (@test_shadowFootprint.R#6)
     4. Error: Shade height calculation is correct (@test_shadowHeight.R#6)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.6.3
Check: dependencies in R code
Result: NOTE
    Namespaces in Imports field not imported from:
     ‘parallel’ ‘plyr’
     All declared Imports should be used.
Flavors: r-devel-linux-x86_64-fedora-clang, r-devel-linux-x86_64-fedora-gcc, r-patched-solaris-x86, r-release-osx-x86_64, r-oldrel-osx-x86_64