Running ‘testthat.R’ [25s/36s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(igraph)
  
  Attaching package: 'igraph'
  
  The following object is masked from 'package:testthat':
  
      compare
  
  The following objects are masked from 'package:stats':
  
      decompose, spectrum
  
  The following object is masked from 'package:base':
  
      union
  
  > 
  > suppressWarnings(RNGversion("3.5.0"))
  > test_check("igraph")
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  igraph
   --- call from context --- 
  graph(n = vc, edges, directed = (mode == "directed"))
   --- call from argument --- 
  if (class(edges) == "formula") {
      if (!missing(n)) 
          stop("'n' should not be given for graph literals")
      if (!missing(isolates)) {
          stop("'isolates' should not be given for graph literals")
      }
      if (!missing(directed)) {
          stop("'directed' should not be given for graph literals")
      }
      mf <- as.list(match.call())[-1]
      mf[[1]] <- mf[[1]][[2]]
      graph_from_literal_i(mf)
  } else {
      if (!missing(simplify)) {
          stop("'simplify' should not be given for graph literals")
      }
      if (!missing(dir) && !missing(directed)) {
          stop("Only give one of 'dir' and 'directed'")
      }
      if (!missing(dir) && missing(directed)) 
          directed <- dir
      if (is.character(edges) && length(edges) == 1) {
          if (!missing(n)) 
              warning("'n' is ignored for the '", edges, "' graph")
          if (!missing(isolates)) {
              warning("'isolates' is ignored for the '", edges, 
                  "' graph")
          }
          if (!missing(directed)) {
              warning("'directed' is ignored for the '", edges, 
                  "' graph")
          }
          if (!missing(dir)) {
              warning("'dir' is ignored for the '", edges, "' graph")
          }
          if (length(list(...))) 
              stop("Extra arguments in make_graph")
          make_famous_graph(edges)
      }
      else if (is.numeric(edges) || is.null(edges) || (is.logical(edges) && 
          length(edges) == 0)) {
          if (is.null(edges) || is.logical(edges)) 
              edges <- as.numeric(edges)
          if (!is.null(isolates)) {
              warning("'isolates' ignored for numeric edge list")
          }
          old_graph <- function(edges, n = max(edges), directed = TRUE) {
              on.exit(.Call(C_R_igraph_finalizer))
              .Call(C_R_igraph_create, as.numeric(edges) - 1, as.numeric(n), 
                  as.logical(directed))
          }
          args <- list(edges, ...)
          if (!missing(n)) 
              args <- c(args, list(n = n))
          if (!missing(directed)) 
              args <- c(args, list(directed = directed))
          do.call(old_graph, args)
      }
      else if (is.character(edges)) {
          if (!missing(n)) {
              warning("'n' is ignored for edge list with vertex names")
          }
          if (length(list(...))) 
              stop("Extra arguments in make_graph")
          el <- matrix(edges, ncol = 2, byrow = TRUE)
          res <- graph_from_edgelist(el, directed = directed)
          if (!is.null(isolates)) {
              isolates <- as.character(isolates)
              res <- res + vertices(isolates)
          }
          res
      }
      else {
          stop("'edges' must be numeric or character")
      }
  }
   --- R stacktrace ---
  where 1: graph(n = vc, edges, directed = (mode == "directed"))
  where 2: graph.adjacency.sparse(adjmatrix, mode = mode, weighted = weighted, 
      diag = diag)
  where 3 at testthat/test_get.adjacency.R#16: graph_from_adjacency_matrix(A, mode = "undirected")
  where 4: eval(code, test_env)
  where 5: eval(code, test_env)
  where 6: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 7: doTryCatch(return(expr), name, parentenv, handler)
  where 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 9: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 10: doTryCatch(return(expr), name, parentenv, handler)
  where 11: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 12: tryCatchList(expr, classes, parentenv, handlers)
  where 13: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 14: test_code(desc, code, env = parent.frame())
  where 15 at testthat/test_get.adjacency.R#4: test_that("as_adj works", {
      library(igraph)
      g <- sample_gnp(50, 1/50)
      A <- as_adj(g, sparse = FALSE)
      g2 <- graph_from_adjacency_matrix(A, mode = "undirected")
      expect_that(graph.isomorphic(g, g2), is_true())
      A <- as_adj(g, sparse = TRUE)
      g2 <- graph_from_adjacency_matrix(A, mode = "undirected")
      expect_that(graph.isomorphic(g, g2), is_true())
      g <- sample_gnp(50, 2/50, directed = TRUE)
      A <- as_adj(g, sparse = FALSE)
      g2 <- graph_from_adjacency_matrix(A)
      expect_that(graph.isomorphic(g, g2), is_true())
      A <- as_adj(g, sparse = TRUE)
      g2 <- graph_from_adjacency_matrix(A)
      expect_that(graph.isomorphic(g, g2), is_true())
  })
  where 16: eval(code, test_env)
  where 17: eval(code, test_env)
  where 18: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 19: doTryCatch(return(expr), name, parentenv, handler)
  where 20: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 21: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 22: doTryCatch(return(expr), name, parentenv, handler)
  where 23: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 24: tryCatchList(expr, classes, parentenv, handlers)
  where 25: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 26: test_code(NULL, exprs, env)
  where 27: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 28: force(code)
  where 29: doWithOneRestart(return(expr), restart)
  where 30: withOneRestart(expr, restarts[[1L]])
  where 31: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 32: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 33: FUN(X[[i]], ...)
  where 34: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 35: force(code)
  where 36: doWithOneRestart(return(expr), restart)
  where 37: withOneRestart(expr, restarts[[1L]])
  where 38: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 39: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 40: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 41: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 42: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 43: test_check("igraph")
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function (edges, ..., n = max(edges), isolates = NULL, directed = TRUE, 
      dir = directed, simplify = TRUE) 
  {
      if (class(edges) == "formula") {
          if (!missing(n)) 
              stop("'n' should not be given for graph literals")
          if (!missing(isolates)) {
              stop("'isolates' should not be given for graph literals")
          }
          if (!missing(directed)) {
              stop("'directed' should not be given for graph literals")
          }
          mf <- as.list(match.call())[-1]
          mf[[1]] <- mf[[1]][[2]]
          graph_from_literal_i(mf)
      }
      else {
          if (!missing(simplify)) {
              stop("'simplify' should not be given for graph literals")
          }
          if (!missing(dir) && !missing(directed)) {
              stop("Only give one of 'dir' and 'directed'")
          }
          if (!missing(dir) && missing(directed)) 
              directed <- dir
          if (is.character(edges) && length(edges) == 1) {
              if (!missing(n)) 
                  warning("'n' is ignored for the '", edges, "' graph")
              if (!missing(isolates)) {
                  warning("'isolates' is ignored for the '", edges, 
                    "' graph")
              }
              if (!missing(directed)) {
                  warning("'directed' is ignored for the '", edges, 
                    "' graph")
              }
              if (!missing(dir)) {
                  warning("'dir' is ignored for the '", edges, 
                    "' graph")
              }
              if (length(list(...))) 
                  stop("Extra arguments in make_graph")
              make_famous_graph(edges)
          }
          else if (is.numeric(edges) || is.null(edges) || (is.logical(edges) && 
              length(edges) == 0)) {
              if (is.null(edges) || is.logical(edges)) 
                  edges <- as.numeric(edges)
              if (!is.null(isolates)) {
                  warning("'isolates' ignored for numeric edge list")
              }
              old_graph <- function(edges, n = max(edges), directed = TRUE) {
                  on.exit(.Call(C_R_igraph_finalizer))
                  .Call(C_R_igraph_create, as.numeric(edges) - 
                    1, as.numeric(n), as.logical(directed))
              }
              args <- list(edges, ...)
              if (!missing(n)) 
                  args <- c(args, list(n = n))
              if (!missing(directed)) 
                  args <- c(args, list(directed = directed))
              do.call(old_graph, args)
          }
          else if (is.character(edges)) {
              if (!missing(n)) {
                  warning("'n' is ignored for edge list with vertex names")
              }
              if (length(list(...))) 
                  stop("Extra arguments in make_graph")
              el <- matrix(edges, ncol = 2, byrow = TRUE)
              res <- graph_from_edgelist(el, directed = directed)
              if (!is.null(isolates)) {
                  isolates <- as.character(isolates)
                  res <- res + vertices(isolates)
              }
              res
          }
          else {
              stop("'edges' must be numeric or character")
          }
      }
  }
  <bytecode: 0x55c2161e8578>
  <environment: namespace:igraph>
   --- function search by body ---
  Function graph in namespace igraph has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Fatal error: the condition has length > 1