Running ‘as.edgelist_tests.R’ [0s/1s]
  Running ‘general.tests.R’ [0s/1s]
  Running ‘general.tests2.R’ [3s/5s]
  Running ‘list.attribute.tests.R’ [1s/2s]
  Running ‘misc_tests.R’ [0s/1s]
  Running ‘network.access.test.R’ [0s/1s]
  Running ‘network.battery.R’ [1s/1s]
  Running ‘pathological.tests.R’ [0s/1s]
  Running ‘plot_tests.R’ [1s/1s]
  Running ‘plotflo.R’ [1s/1s]
  Running ‘read.paj_tests.R’ [1s/3s]
  Running ‘speedTests.R’ [6s/8s]
  Running ‘vignette.R’ [1s/1s]
Running the tests in ‘tests/as.edgelist_tests.R’ failed.
Complete output:
  > 
  > # test comparing edgelist
  > 
  > require(network)
  Loading required package: network
  network: Classes for Relational Data
  Version 1.15 created on 2019-04-01.
  copyright (c) 2005, Carter T. Butts, University of California-Irvine
                      Mark S. Handcock, University of California -- Los Angeles
                      David R. Hunter, Penn State University
                      Martina Morris, University of Washington
                      Skye Bender-deMoll, University of Washington
   For citation information, type citation("network").
   Type help("network-package") to get started.
  
  > require(testthat)
  Loading required package: testthat
  > 
  > test<-network.initialize(5)
  > add.edges(test,5,1)
  > add.edges(test,1,5)
  > set.edge.attribute(test,'value',c('a','b'))
  > set.edge.attribute(test,'weight',10:11)
  > 
  > expect_equal(as.matrix.network.edgelist(test),structure(c(5L, 1L, 1L, 5L), .Dim = c(2L, 2L), n = 5, vnames = 1:5))
  > # sort order should be different
  > expect_equal(as.edgelist(test),structure(c(1L, 5L, 5L, 1L), .Dim = c(2L, 2L), n = 5, vnames = 1:5, directed = TRUE, bipartite = FALSE, loops = FALSE, class = c("edgelist","matrix")))
  Error: as.edgelist(test) not equal to structure(...).
  Attributes: < Component "class": Lengths (3, 2) differ (string compare on first 2) >
  Execution halted
Running the tests in ‘tests/list.attribute.tests.R’ failed.
Complete output:
  > require(network)
  Loading required package: network
  network: Classes for Relational Data
  Version 1.15 created on 2019-04-01.
  copyright (c) 2005, Carter T. Butts, University of California-Irvine
                      Mark S. Handcock, University of California -- Los Angeles
                      David R. Hunter, Penn State University
                      Martina Morris, University of Washington
                      Skye Bender-deMoll, University of Washington
   For citation information, type citation("network").
   Type help("network-package") to get started.
  
  > 
  > # --------- test list.vertex.attributes ---
  > 
  > net<-network.initialize(3)
  > 
  > list.vertex.attributes(net)
  [1] "na"           "vertex.names"
  > 
  > if(!all(list.vertex.attributes(net)==c('na','vertex.names'))){
  +   stop('list.vertex.attribute did not report default attributes corrrectly')
  + }
  > 
  > set.vertex.attribute(net,'letters',c("a","b","c"))
  > 
  > if(!all(list.vertex.attributes(net)==c('letters','na','vertex.names'))){
  +   stop('list.vertex.attribute did not report added attributes corrrectly')
  + }
  > 
  > 
  > # ----- test list.edge.attributes ----
  > 
  > net<-network.initialize(3)
  > if(length(list.edge.attributes(net))!=0){
  +   stop("list.edge.attributes did not return empty list for network with no edges")
  + }
  > 
  > add.edges(net,1,2)
  > add.edges(net,2,3)
  > if(list.edge.attributes(net)!='na'){
  +   stop("list.edge.attributes did not return 'na' for network with only edges")
  + }
  > 
  > set.edge.attribute(net,'letter',c("a","b"))
  > if(!all(list.edge.attributes(net)==c('letter','na'))){
  +   stop("list.edge.attributes did not return attribute names for network with edges")
  + }
  >    
  > delete.edges(net,eid=1)   
  > if(!all(list.edge.attributes(net)==c('letter','na'))){
  +    stop("list.edge.attributes did not return attribute names for network deleted edge")
  + }
  >    
  > # ---- test list.network.attributes ----
  > net<-network.initialize(3)   
  > if(!all(list.network.attributes(net)==c("bipartite", "directed",  "hyper","loops","mnext",     "multiple","n" ))){
  +   stop("list.network.attributes returned unexpected values for default attributes of a network")
  + } 
  >    
  > set.network.attribute(net,'letter',"a")   
  >    if(!all(list.network.attributes(net)==c("bipartite", "directed",  "hyper","letter","loops","mnext",     "multiple","n" ))){
  +      stop("list.network.attributes returned unexpected values for network with attribute added")
  +    } 
  > 
  > # ----- tests for printing function for edges cases ------
  > net<-network.initialize(100)
  > net%n%'a_matrix'<-matrix(1:100,nrow=10,ncol=10)
  > net%n%'a_null'<-NULL
  > net%n%'a_list'<-list(part1=list(c("A","B")),part2=list("c"))
  > net%n%'a_desc_vec'<-numeric(rep(100,1))
  > net%n%'a_net'<-network.initialize(5)
  > print.network(net)
   Network attributes:
    vertices = 100 
    directed = TRUE 
    hyper = FALSE 
    loops = FALSE 
    multiple = FALSE 
    bipartite = FALSE 
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  network
   --- call from context --- 
  print.network(net)
   --- call from argument --- 
  if (class(attributeValue) %in% c("matrix")) {
      cat("  ", attributeName, ": ", nrow(attributeValue), "x", 
          ncol(attributeValue), " matrix\n", sep = "")
  } else {
      cat("  ", attributeName, ":\n", sep = "")
      if (is.call(attributeValue)) {
          print(attributeValue)
      }
      else {
          print(summary(attributeValue))
      }
  }
   --- R stacktrace ---
  where 1: print.network(net)
  
   --- value of length: 2 type: logical ---
  [1]  TRUE FALSE
   --- function from context --- 
  function (x, matrix.type = which.matrix.type(x), mixingmatrices = FALSE, 
      na.omit = TRUE, print.adj = FALSE, ...) 
  {
      cat(" Network attributes:\n")
      for (i in 1:length(x$gal)) {
          if (names(x$gal)[i] == "n") {
              attributeName <- "vertices"
              attributeValue <- x$gal[[i]]
          }
          else {
              attributeName <- names(x$gal)[i]
              attributeValue <- x$gal[[i]]
          }
          if (is.network(attributeValue)) {
              if (attributeName == "design") {
                  cat(" ", attributeName, "=\n")
                  cat("      total missing =", network.edgecount(attributeValue), 
                    "\n")
                  cat("    percent missing =", network.density(attributeValue), 
                    "\n")
              }
              else {
                  cat(" ", attributeName, ":\n", sep = "")
                  if (is.discrete(attributeValue)) {
                    assign(paste(" ", attributeName), attributeValue)
                    print(table(get(paste(" ", attributeName))))
                    if (mixingmatrices) {
                      cat("\n", "mixing matrix for ", attributeName, 
                        ":\n", sep = "")
                      print(mixingmatrix(x, attributeName))
                    }
                  }
                  else {
                    print(summary(attributeValue))
                  }
              }
          }
          else {
              if (attributeName != "mnext") {
                  if (is.discrete(attributeValue)) {
                    print(table(attributeValue, dnn = paste("  ", 
                      attributeName, ":", sep = "")))
                  }
                  else {
                    if ((class(attributeValue) %in% c("factor", 
                      "character", "numeric", "logical", "integer", 
                      "double", "NULL", "call", "formula")) && 
                      (length(attributeValue) < 10)) {
                      if (is.null(attributeValue)) {
                        cat(" ", attributeName, "= NULL\n")
                      }
                      else {
                        if (is.call(attributeValue)) 
                          attributeValue <- deparse(attributeValue)
                        cat(" ", attributeName, "=", attributeValue, 
                          "\n")
                      }
                    }
                    else {
                      if (attributeName == "net.obs.period" || 
                        grepl(".active$", attributeName)) {
                        cat("  ", attributeName, ": (not shown)\n", 
                          sep = "")
                      }
                      else if (class(attributeValue) %in% c("matrix")) {
                        cat("  ", attributeName, ": ", nrow(attributeValue), 
                          "x", ncol(attributeValue), " matrix\n", 
                          sep = "")
                      }
                      else {
                        cat("  ", attributeName, ":\n", sep = "")
                        if (is.call(attributeValue)) {
                          print(attributeValue)
                        }
                        else {
                          print(summary(attributeValue))
                        }
                      }
                    }
                  }
              }
          }
      }
      cat("  total edges=", network.edgecount(x, na.omit = FALSE), 
          "\n")
      cat("    missing edges=", network.naedgecount(x), "\n")
      cat("    non-missing edges=", network.edgecount(x, na.omit = TRUE), 
          "\n")
      vna <- list.vertex.attributes(x)
      if (na.omit) {
          vna <- vna[vna != "na"]
      }
      if (length(vna) == 0) {
          cat("\n", "No vertex attributes", "\n", sep = "")
      }
      else {
          cat("\n", "Vertex attribute names:", "\n")
          cat("   ", vna, "\n")
      }
      if (length(x$mel) <= 1000) {
          ena <- list.edge.attributes(x)
          if (na.omit) {
              ena <- ena[ena != "na"]
          }
          if (length(ena) == 0) {
              cat("\n", "No edge attributes", "\n", sep = "")
          }
          else {
              cat("\n", "Edge attribute names:", "\n")
              cat("   ", ena, "\n")
          }
      }
      else {
          cat("\n", "Edge attribute names not shown", "\n")
      }
      if (print.adj) {
          if (is.multiplex(x) && (matrix.type == "adjacency")) 
              matrix.type <- "edgelist"
          if (is.hyper(x)) 
              matrix.type <- "incidence"
          cat("\n", matrix.type, "matrix:\n")
          if (network.edgecount(x) > 0) {
              mat <- as.matrix.network(x, matrix.type = matrix.type)
              attr(mat, "n") <- NULL
              attr(mat, "vnames") <- NULL
              attr(mat, "bipartite") <- NULL
              print(mat)
          }
          else cat("Empty Graph\n")
      }
      invisible(x)
  }
  <bytecode: 0x55797fbab5c8>
  <environment: namespace:network>
   --- function search by body ---
  Function print.network in namespace network has this body.
   ----------- END OF FAILURE REPORT -------------- 
  Fatal error: the condition has length > 1
Running the tests in ‘tests/plot_tests.R’ failed.
Complete output:
  > # various tests for network plotting functions
  > # mostly recent functionality added by skyebend
  > require(network)
  Loading required package: network
  network: Classes for Relational Data
  Version 1.15 created on 2019-04-01.
  copyright (c) 2005, Carter T. Butts, University of California-Irvine
                      Mark S. Handcock, University of California -- Los Angeles
                      David R. Hunter, Penn State University
                      Martina Morris, University of Washington
                      Skye Bender-deMoll, University of Washington
   For citation information, type citation("network").
   Type help("network-package") to get started.
  
  > require(testthat)
  Loading required package: testthat
  > # -----  test edge labels ------
  > ymat<-matrix(c(0,1,2,3, 0,0,0,0, 1,0,0,0, 0,0,0,0),ncol=4)
  > ynet<-network(ymat,ignore.eval=FALSE,names.eval='weight')
  > # don't do anything if no value given
  > plot(ynet,edge.label.col='blue',edge.label.cex='weight')
  > # use edge ids is if edge.label=TRUE
  > plot(ynet,edge.label=TRUE)
  > 
  > plot(ynet,edge.label='weight',edge.label.col='blue',edge.label.cex='weight')
  > 
  > # labels for curved edges
  > plot(ynet,edge.label='weight',edge.label.col='blue',edge.label.cex='weight',usecurve=TRUE)
  > plot(ynet,edge.label='weight',edge.label.col='blue',edge.label.cex='weight',usecurve=TRUE,edge.curve=0.5)
  > 
  > data(emon)
  > par(mar=c(0,0,0,0))
  > plot(emon[[5]],edge.label=TRUE,edge.label.cex=0.6,edge.col='gray',edge.lwd=(emon[[5]]%e%'Frequency')*2)
  > 
  > # test for labeling network with no edges #521
  > plot(network.initialize(1),edge.label=TRUE)
  > 
  > # test color stuff
  > 
  > col.list<-c('red','#800000','#80000505',NA)
  > # test is.color for vector NA processing bug #491
  > if(!all(is.color(col.list)[1:3] & is.na(is.color(col.list)[4]))){
  +   stop('is.color did not correctly recognize colors and NA values in a character vector')
  + }
  >    
  > col.list<-list('red','#800000','#80000505',NA)
  > # test is.color for list NA processing bug #491
  > if(!all(is.color(col.list)[1:3] & is.na(is.color(col.list)[4]))){
  +   stop('is.color did not correctly recognize colors and NA values in a list')
  + }
  > 
  > # ------------ as.color --------
  > 
  > expect_equal(as.color(c('a','b','c')),1:3)  # character
  > expect_equal(as.color(1:3),1:3)  # numeric
  > expect_equal(as.color(as.factor(c('a','b','c'))),1:3)  # factor
  > expect_equal(as.color(c('red','green','blue')),c('red','green','blue'))  # color name
  > expect_equal(as.color(c(1,0.5,0)),c("#FFFFFF", "#808080", "#000000"))# real valued  (gray)
  > # transparency/ opacity
  > expect_equal(as.color(c('red','green','blue'),0.5),c("#FF000080", "#00FF0080", "#0000FF80"))
  > expect_equal(as.color(1:3,0.5),c("#00000080", "#FF000080", "#00CD0080"))
  Error: as.color(1:3, 0.5) not equal to c("#00000080", "#FF000080", "#00CD0080").
  2/3 mismatches
  x[2]: "#DF536B80"
  y[2]: "#FF000080"
  
  x[3]: "#61D04F80"
  y[3]: "#00CD0080"
  Execution halted