Running 'testthat.R' [11s/12s]
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: 0xa5d1388>
  <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: 0xa5d1388>
  <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: 0xa5d1388>
  <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: 0xa5d1388>
  <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