Running ‘activate_tests.R’
  Running ‘age.at_tests.R’
  Running ‘classTests.R’
  Running ‘converter_tests.R’
  Running ‘get_tests.R’
  Running ‘import_tests.R’
  Running ‘network_tests.R’
  Running ‘pid_tests.R’
  Running ‘query_tests.R’
  Running ‘reconcile.activityTests.R’
  Running ‘tea_tests.R’
  Running ‘utils_tests.R’
  Running ‘when_tests.R’
Running the tests in ‘tests/activate_tests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > 
  > ########################################################################
  > # This file contains the testing suite for the "activate" methods, i.e.:
  > #      activate.edges        deactivate.edges
  > #      activate.vertices     deactivate.vertices     
  > #########################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > 
  > #------------------- ACTIVATE.EDGES TESTS ------------------------
  > # Notes:
  > #  --except for the error-checking code, the rest of the tests
  > #    are meant to be exhaustive
  > #-----------------------------------------------------------------
  > 
  > cat("testing activate.edges ... ")
  testing activate.edges ... > anet <- network.initialize(100)
  > set.seed(10)
  > heads <- sample(100, 150, replace=TRUE)
  > set.seed(25)
  > tails <- sample(100, 150, replace=TRUE)
  > add.edges(anet, tails, heads)
  > anet.copy <- anet
  > 
  > # proper behavior for bad inputs?
  > #  -- bad network input
  > a1 = try(activate.edges(3, e=1), T)                    # properly handeled
  > #  -- bad at times
  > a2 = try(activate.edges(anet, at="a", e=2), T)         # properly handeled
  > #  -- bad onset
  > a3 = try(activate.edges(anet, "a", e=3), T)            # properly handeled
  > a4 = try(activate.edges(anet, NULL, 3, e=4), T)        # properly handeled
  > # -- bad terminus
  > a5 = try(activate.edges(anet, 3, "b", e=5), T)         # properly handeled
  > # -- bad length
  > a6 = try(activate.edges(anet, 3, length=-9, e=6), T)   # properly handeled
  > a7 = try(activate.edges(anet, 3, length="r", e=7), T)  # properly handeled
  > # -- bad edges
  > a8 = try(activate.edges(anet, 3, 10, e=174), T)        # properly handeled
  > a9 = try(activate.edges(anet, 3, 10, e=-2), T)         # properly handeled
  > a10 = try(activate.edges(anet, 3, 10, e=NULL), T)      # properly handeled
  > a11 = try(activate.edges(anet, 3, 10, e="hello"), T)   # properly handeled
  > # -- bad onset & terminus combo
  > a12 = try(activate.edges(anet, 10, 3, e=8), T)         # properly handeled
  > # -- not fully specified intervals
  > a13 = try(activate.edges(anet, 10, e=9), T)            # properly handeled
  > a14 = try(activate.edges(anet, terminus=10, e=10), T)  # properly handeled
  > a15 = try(activate.edges(anet, length=10, e=11), T)    # properly handeled
  > 
  > 
  > # good input
  > anet <- anet.copy
  > # for edges lacking an active attribute
  > activate.edges(anet, Inf, Inf, e=1)         # add (Inf, Inf) spell
  > b1 = is.null(anet$mel[[1]]$atl$active)
  > activate.edges(anet, -Inf, -Inf, e=2)       # add (-Inf, -Inf) spell
  > b2 = is.null(anet$mel[[2]]$atl$active)
  > activate.edges(anet, -Inf, Inf, e=3)        # add (-Inf, Inf) spell
  > b3 = identical(anet$mel[[3]]$atl$active,
  +               matrix(c(-Inf, Inf), 1,2))
  > activate.edges(anet, -Inf, Inf, e=4)        # add (-Inf, Inf) spell
  > b4 = identical(anet$mel[[4]]$atl$active,
  +               matrix(c(-Inf, Inf), 1,2))
  > activate.edges(anet, -Inf, 10,  e=5)        # add (-Inf, b) spell
  > b5 = identical(anet$mel[[5]]$atl$active,
  +               matrix(c(-Inf, 10), 1,2))
  > activate.edges(anet, 0, Inf, e=6)           # add (a, Inf) spell
  > b6 = identical(anet$mel[[6]]$atl$active,
  +               matrix(c(0, Inf), 1,2))
  > activate.edges(anet, -10, Inf, e=7)         # add (a, Inf) spell
  > b7 = identical(anet$mel[[7]]$atl$active,
  +               matrix(c(-10, Inf), 1,2))
  > activate.edges(anet, 10, 20, e=8)           # add (a, b) spell
  > b8 = identical(anet$mel[[8]]$atl$active,
  +               matrix(c(10, 20), 1,2))
  > activate.edges(anet, 10, 10, e=9)           # add (a, a) spell
  > b8 = identical(anet$mel[[9]]$atl$active,
  +               matrix(c(10, 10), 1,2))
  > 
  > b.tests = paste("b", seq(1,8), sep="")
  > b.results= sapply(b.tests, function(x){eval(parse(text=x))})
  > if(any(!b.results)){
  +   bad.tests = paste("b", which(!b.results), sep="", collapse=" ")
  +   stop(paste("activate.edges is incorrectly activating edges in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # for edges already having an active attribute
  > anet <- anet.copy
  > 
  > # Notes:
  > #    - a, b are upper, lower boundary points
  > #    - L is a finite number lower than a
  > #    - M is a finite number in between a and b
  > #    - H is a finite number higher than b
  > #    -Gij is a finite number that is in the gap b/t intervals i and j
  > 
  > # tests for activation at a point
  > for (i in 1:3)
  +   anet$mel[[i]]$atl$active <- matrix(c(Inf,Inf), 1,2)
  > for (i in 4:6)
  +   anet$mel[[i]]$atl$active <- matrix(c(-Inf,-Inf), 1,2)
  > activate.edges(anet, -Inf,  Inf, e=7:9)
  > activate.edges(anet, -Inf,   20, e=10:13)
  > activate.edges(anet,   10,  Inf, e=14:17)
  > activate.edges(anet,   10,   20, e=18:24)
  > activate.edges(anet,   10,   10, e=25:26)
  > 
  > activate.edges(anet, at=c(-Inf, Inf, 0, -Inf, Inf,  0, -Inf, Inf,  0, -Inf, 20,   0, 30, Inf, 10, 30,  0, -Inf, Inf, 10, 20, 15, 30,  0, 10, 20),
  +                     e = c(   1,   2, 3,    4,   5,  6,    7,   8,  9,   10, 11,  12, 13,  14, 15, 16, 17,   18,  19, 20, 21, 22, 23, 24, 25, 26))  
  > c1  = identical(anet$mel[[1]]$atl$active,      # add -Inf to  (Inf, Inf)
  +       matrix(c(Inf, Inf),1,2))    
  > c2  = identical(anet$mel[[2]]$atl$active,      # add Inf  to  (Inf, Inf)
  +       matrix(c(Inf, Inf),1,2))    
  > c3  = identical(anet$mel[[3]]$atl$active,      # add M    to  (Inf, Inf)
  +       matrix(c(0, 0),1,2))  
  > c4  = identical(anet$mel[[4]]$atl$active,      # add -Inf to  (-Inf, -Inf)
  +       matrix(c(-Inf, -Inf),1,2))    
  > c5  = identical(anet$mel[[5]]$atl$active,      # add Inf  to  (-Inf, -Inf)
  +       matrix(c(-Inf, -Inf),1,2))    
  > c6  = identical(anet$mel[[6]]$atl$active,      # add M    to  (-Inf, -Inf)
  +       matrix(c(0, 0),1,2))    
  > c7  = identical(anet$mel[[7]]$atl$active,      # add -Inf to  (-Inf, Inf)
  +       matrix(c(-Inf, Inf),1,2))    
  > c8  = identical(anet$mel[[8]]$atl$active,      # add Inf  to  (-Inf, Inf)
  +       matrix(c(-Inf, Inf),1,2))    
  > c9  = identical(anet$mel[[9]]$atl$active,      # add M    to  (-Inf, Inf)
  +       matrix(c(-Inf, Inf),1,2))    
  > c10 = identical(anet$mel[[10]]$atl$active,     # add -Inf to  (-Inf, b)
  +       matrix(c(-Inf, 20),1,2))      
  > c11 = identical(anet$mel[[11]]$atl$active,     # add b    to  (-Inf, b)
  +       matrix(c(-Inf,20,20,20),2,2))    
  > c12 = identical(anet$mel[[12]]$atl$active,     # add M    to  (-Inf, b)
  +       matrix(c(-Inf, 20),1,2))    
  > c13 = identical(anet$mel[[13]]$atl$active,     # add H    to  (-Inf, b)
  +       matrix(c(-Inf,30,20,30),2,2))      
  > c14 = identical(anet$mel[[14]]$atl$active,     # add Inf  to  (a, Inf)
  +       matrix(c(10, Inf),1,2))    
  > c15 = identical(anet$mel[[15]]$atl$active,     # add a    to  (a, Inf)
  +       matrix(c(10, Inf),1,2))    
  > c16 = identical(anet$mel[[16]]$atl$active,     # add M    to  (a, Inf)
  +       matrix(c(10, Inf),1,2))    
  > c17 = identical(anet$mel[[17]]$atl$active,     # add L    to  (a, Inf)
  +       matrix(c(0,10,0,Inf),2,2))    
  > c18 = identical(anet$mel[[18]]$atl$active,     # add -Inf to  (a,b)
  +       matrix(c(10,20),1,2))    
  > c19 = identical(anet$mel[[19]]$atl$active,     # add Inf  to  (a,b)
  +       matrix(c(10, 20),1,2))    
  > c20 = identical(anet$mel[[20]]$atl$active,     # add a    to  (a,b)
  +       matrix(c(10,20),1,2))    
  > c21 = identical(anet$mel[[21]]$atl$active,     # add b    to  (a,b)
  +       matrix(c(10,20,20,20),2,2))    
  > c22 = identical(anet$mel[[22]]$atl$active,     # add M    to  (a,b)
  +       matrix(c(10, 20),1,2))    
  > c23 = identical(anet$mel[[23]]$atl$active,     # add H    to  (a,b)
  +       matrix(c(10,30,20,30),2,2))    
  > c24 = identical(anet$mel[[24]]$atl$active,     # add L    to  (a,b)    
  +       matrix(c(0,10,0,20),2,2))  
  > c25 = identical(anet$mel[[25]]$atl$active,     # add a    to  (a,a)    
  +       matrix(c(10,10),1,2))  
  > c26 = identical(anet$mel[[26]]$atl$active,     # add H    to  (a,a)    
  +       matrix(c(10,20,10,20),2,2))  
  >   
  > c.tests = paste("c", seq(1,26), sep="")
  > c.results= sapply(c.tests, function(x){eval(parse(text=x))})
  > if(any(!c.results)){
  +   bad.tests = paste("c", which(!c.results), sep="", collapse=" ")
  +   stop(paste("activate.edges is incorrectly activating edges in tests",
  +              bad.tests))
  + }
  > 
  > 
  > anet <- anet.copy
  > for (i in 1:7)
  +   anet$mel[[i]]$atl$active <- matrix(c(Inf,Inf), 1,2)
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf,  10, 10, 10),
  +                      c(Inf, -Inf,  Inf,   10, Inf, 20, 10),
  +                  e = c(  1,    2,    3,    4,   5,  6,  7))
  > d1  = identical(anet$mel[[1]]$atl$active,   # add (Inf, Inf)   to (Inf, Inf) spell
  +       matrix(c(Inf, Inf), 1,2))
  > d2  = identical(anet$mel[[2]]$atl$active,   # add (-Inf, -Inf) to (Inf, Inf) spell
  +       matrix(c(Inf, Inf), 1,2))
  > d3  = identical(anet$mel[[3]]$atl$active,   # add (-Inf, Inf)  to (Inf, Inf) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d4  = identical(anet$mel[[4]]$atl$active,   # add (-Inf, b)    to (Inf, Inf) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d5  = identical(anet$mel[[5]]$atl$active,   # add (a, Inf)     to (Inf, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d6  = identical(anet$mel[[6]]$atl$active,   # add (a, b)       to (Inf, Inf) spell
  +       matrix(c(10, 20), 1,2))
  > d7  = identical(anet$mel[[7]]$atl$active,   # add (a, a)       to (Inf, Inf) spell
  +       matrix(c(10, 10), 1,2))
  > 
  > 
  > for (i in 8:14)
  +   anet$mel[[i]]$atl$active <- matrix(c(-Inf, -Inf), 1,2)
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf,  10, 10, 20),
  +                      c(Inf, -Inf,  Inf,   10, Inf, 20, 20),
  +                  e = c(  8,    9,   10,  11,   12, 13, 14))
  > d8  = identical(anet$mel[[8]]$atl$active,   # add (Inf, Inf)   to (-Inf, -Inf) spell
  +       matrix(c(-Inf, -Inf), 1,2))
  > d9  = identical(anet$mel[[9]]$atl$active,   # add (-Inf, -Inf) to (-Inf, -Inf) spell
  +       matrix(c(-Inf, -Inf), 1,2))
  > d10  = identical(anet$mel[[10]]$atl$active, # add (-Inf, Inf)  to (-Inf, -Inf) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d11 = identical(anet$mel[[11]]$atl$active,  # add (-Inf, H)    to (-Inf, -Inf) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d12 = identical(anet$mel[[12]]$atl$active,  # add (H, Inf)     to (-Inf, -Inf) spell
  +       matrix(c(10,  Inf), 1,2, byrow=T))
  > d13 = identical(anet$mel[[13]]$atl$active,  # add (H1, H2)       to -(Inf, -Inf) spell
  +       matrix(c(10,  20), 1,2, byrow=T))
  > d14 = identical(anet$mel[[14]]$atl$active,  # add (H1, H1)       to -(Inf, -Inf) spell
  +       matrix(c(20,  20), 1,2, byrow=T))
  > 
  > 
  > activate.edges(anet, -Inf, 10, e=seq(15,32))
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf, -Inf, -Inf,   0,  10,  20,  0, 10, 10,  0, -5,  0, 20, 20, 10),
  +                      c(Inf, -Inf,  Inf,    0,   10,   20, Inf, Inf, Inf, 10, 10, 20,  0,  0, 20, 30, 20, 10),
  +                  e = c( 15,   16,   17,   18,   19,   20,  21,  22,  23, 24, 25, 26, 27, 28, 29, 30, 31, 32))
  > d15 = identical(anet$mel[[15]]$atl$active,   # add (Inf, Inf)   to (-Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d16 = identical(anet$mel[[16]]$atl$active,   # add (-Inf, -Inf) to (-Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d17 = identical(anet$mel[[17]]$atl$active,   # add (-Inf, Inf)  to (-Inf, b) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d18 = identical(anet$mel[[18]]$atl$active,   # add (-Inf, M)    to (-Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d19 = identical(anet$mel[[19]]$atl$active,   # add (-Inf, b)    to (-Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2)) 
  > d20 = identical(anet$mel[[20]]$atl$active,   # add (-Inf, H)    to (-Inf, b) spell
  +       matrix(c(-Inf, 20), 1,2))
  > d21 = identical(anet$mel[[21]]$atl$active,   # add (M, Inf)     to (-Inf, b) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d22 = identical(anet$mel[[22]]$atl$active,   # add (b, Inf)     to (-Inf, b) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d23 = identical(anet$mel[[23]]$atl$active,   # add (H, Inf)     to (-Inf, b) spell
  +       matrix(c(-Inf,20,10,Inf),2,2))
  > d24 = identical(anet$mel[[24]]$atl$active,   # add (M, b)       to (-Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))
  > d25 = identical(anet$mel[[25]]$atl$active,   # add (b, b)       to (-Inf, b) spell
  +       matrix(c(-Inf, 10,10,10), 2,2))
  > d26 = identical(anet$mel[[26]]$atl$active,   # add (b, H)       to (-Inf, b) spell
  +       matrix(c(-Inf, 20), 1,2))
  > d27 = identical(anet$mel[[27]]$atl$active,   # add (M, M)       to -(Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))  
  > d28 = identical(anet$mel[[28]]$atl$active,   # add (M1, M2)     to -(Inf, b) spell
  +       matrix(c(-Inf, 10), 1,2))    
  > d29 = identical(anet$mel[[29]]$atl$active,   # add (M, H)       to -(Inf, b) spell
  +       matrix(c(-Inf, 20), 1,2))  
  > d30 = identical(anet$mel[[30]]$atl$active,   # add (H1, H2)     to -(Inf, b) spell
  +       matrix(c(-Inf,20,10,30),2,2))
  > d31 = identical(anet$mel[[31]]$atl$active,   # add (H, H)       to -(Inf, b) spell
  +       matrix(c(-Inf,20,10,20),2,2))
  > d32 = identical(anet$mel[[32]]$atl$active,   # add (b, b)       to -(Inf, b) spell
  +       matrix(c(-Inf,10,10,10),2,2))
  > 
  > 
  > activate.edges(anet, 10, Inf, e=seq(33,49))
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf, -Inf, -Inf,   0,  10,  20,  0, 10, 10,  0, -5, 20,  0, 20),
  +                      c(Inf, -Inf,  Inf,    0,   10,   20, Inf, Inf, Inf, 10, 10, 20,  5, 20, 30,  0, 20),
  +                  e = c( 33,   34,   35,   36,   37,   38,  39,  40,  41, 42, 43, 44, 45, 46, 47, 48, 49))
  > d33 = identical(anet$mel[[33]]$atl$active,   # add (Inf, Inf)   to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d34 = identical(anet$mel[[34]]$atl$active,   # add (-Inf, -Inf) to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d35 = identical(anet$mel[[35]]$atl$active,   # add (-Inf, Inf)  to (a, Inf) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d36 = identical(anet$mel[[36]]$atl$active,   # add (-Inf, L)    to (a, Inf) spell
  +       matrix(c(-Inf,10,0,Inf),2,2))
  > d37 = identical(anet$mel[[37]]$atl$active,   # add (-Inf, a)    to (a, Inf) spell
  +       matrix(c(-Inf, Inf), 1,2)) 
  > d38 = identical(anet$mel[[38]]$atl$active,   # add (-Inf, M)    to (a, Inf) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d39 = identical(anet$mel[[39]]$atl$active,   # add (L, Inf)     to (a, Inf) spell
  +       matrix(c(0, Inf), 1,2))
  > d40 = identical(anet$mel[[40]]$atl$active,   # add (a, Inf)     to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d41 = identical(anet$mel[[41]]$atl$active,   # add (M, Inf)     to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d42 = identical(anet$mel[[42]]$atl$active,   # add (L, a)       to (a, Inf) spell
  +       matrix(c(0, Inf), 1,2))
  > d43 = identical(anet$mel[[43]]$atl$active,   # add (a, a)       to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d44 = identical(anet$mel[[44]]$atl$active,   # add (a, M)       to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d45 = identical(anet$mel[[45]]$atl$active,   # add (L1, L2)     to (a, Inf) spell
  +       matrix(c(0,10,5,Inf),2,2))
  > d46 = identical(anet$mel[[46]]$atl$active,   # add (L, M)       to (a, Inf) spell
  +       matrix(c(-5, Inf), 1,2))    
  > d47 = identical(anet$mel[[47]]$atl$active,   # add (M1, M2)     to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > d48 = identical(anet$mel[[48]]$atl$active,   # add (L, L)       to (a, Inf) spell
  +       matrix(c(0,10,0,Inf), 2,2))
  > d49 = identical(anet$mel[[49]]$atl$active,   # add (H, H)       to (a, Inf) spell
  +       matrix(c(10, Inf), 1,2))
  > 
  > 
  > activate.edges(anet, 10, 20, e=seq(50,76))
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf, -Inf, -Inf, -Inf, -Inf,   0,  10,  15,  20,  30,  0, 10, 10, 10, 10,  0, 20, 20, -5,  0,  0, 12, 15, 30),
  +                      c(Inf, -Inf,  Inf,    0,   10,   15,   20,   30, Inf, Inf, Inf, Inf, Inf, 10, 10, 15, 20, 30, 20, 20, 30,  0, 15, 30, 15, 30, 40),
  +                  e = c( 50,   51,   52,   53,   54,   55,   56,   57,  58,  59,  60,  61,  62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76))
  > d50 = identical(anet$mel[[50]]$atl$active,   # add (Inf, Inf)   to (a, b) spell
  +       matrix(c(10,20), 1,2))
  > d51 = identical(anet$mel[[51]]$atl$active,   # add (-Inf, -Inf) to (a, b) spell
  +       matrix(c(10,20), 1,2))  
  > d52 = identical(anet$mel[[52]]$atl$active,   # add (-Inf, Inf)  to (a, b) spell
  +       matrix(c(-Inf, Inf), 1,2))
  > d53 = identical(anet$mel[[53]]$atl$active,   # add (-Inf, L)    to (a, b) spell
  +       matrix(c(-Inf,10,0,20),2,2))
  > d54 = identical(anet$mel[[54]]$atl$active,   # add (-Inf, a)    to (a, b) spell
  +       matrix(c(-Inf, 20), 1,2)) 
  > d55 = identical(anet$mel[[55]]$atl$active,   # add (-Inf, M)    to (a, b) spell
  +       matrix(c(-Inf, 20), 1,2))
  > d56 = identical(anet$mel[[56]]$atl$active,   # add (-Inf, b)    to (a, b) spell
  +       matrix(c(-Inf, 20), 1,2)) 
  > d57 = identical(anet$mel[[57]]$atl$active,   # add (-Inf, H)    to (a, b) spell
  +       matrix(c(-Inf, 30), 1,2))
  > d58 = identical(anet$mel[[58]]$atl$active,   # add (L, Inf)     to (a, b) spell
  +       matrix(c(0, Inf), 1,2))
  > d59 = identical(anet$mel[[59]]$atl$active,   # add (a, Inf)     to (a, b) spell
  +       matrix(c(10, Inf), 1,2))
  > d60 = identical(anet$mel[[60]]$atl$active,   # add (M, Inf)     to (a, b) spell
  +       matrix(c(10, Inf), 1,2))
  > d61 = identical(anet$mel[[61]]$atl$active,   # add (b, Inf)     to (a, b) spell
  +       matrix(c(10, Inf), 1,2))
  > d62 = identical(anet$mel[[62]]$atl$active,   # add (H, Inf)     to (a, b) spell
  +       matrix(c(10,30,20,Inf),2,2))
  > d63 = identical(anet$mel[[63]]$atl$active,   # add (L, a)       to (a, b) spell
  +       matrix(c(0, 20), 1,2))
  > d64 = identical(anet$mel[[64]]$atl$active,   # add (a, a)       to (a, b) spell
  +       matrix(c(10, 20), 1,2))
  > d65 = identical(anet$mel[[65]]$atl$active,   # add (a, M)       to (a, b) spell
  +       matrix(c(10, 20), 1,2))
  > d66 = identical(anet$mel[[66]]$atl$active,   # add (a, b)       to (a, b) spell
  +       matrix(c(10, 20), 1,2))
  > d67 = identical(anet$mel[[67]]$atl$active,   # add (a, H)       to (a, b) spell
  +       matrix(c(10, 30), 1,2))
  > d68 = identical(anet$mel[[68]]$atl$active,   # add (L, b)       to (a, b) spell
  +       matrix(c(0, 20), 1,2))
  > d69 = identical(anet$mel[[69]]$atl$active,   # add (b, b)       to (a, b) spell
  +       matrix(c(10, 20,20,20), 2,2))
  > d70 = identical(anet$mel[[70]]$atl$active,   # add (b, H)       to (a, b) spell
  +       matrix(c(10, 30), 1,2))
  > d71 = identical(anet$mel[[71]]$atl$active,   # add (L1, L2)     to (a, b) spell
  +       matrix(c(-5,10,0,20),2,2))
  > d72 = identical(anet$mel[[72]]$atl$active,   # add (L, M)       to (a, b) spell
  +       matrix(c(0, 20), 1,2))    
  > d73 = identical(anet$mel[[73]]$atl$active,   # add (L, H)       to (a, b) spell
  +       matrix(c(0, 30), 1,2))    
  > d74 = identical(anet$mel[[74]]$atl$active,   # add (M1, M2)     to (a, b) spell
  +       matrix(c(10, 20), 1,2))
  > d75 = identical(anet$mel[[75]]$atl$active,   # add (M, H)       to (a, b) spell
  +       matrix(c(10, 30), 1,2))    
  > d76 = identical(anet$mel[[76]]$atl$active,   # add (H1, H2)     to (a, b) spell
  +       matrix(c(10,30,20,40),2,2))
  > 
  > activate.edges(anet, -Inf,  10, e=seq(77, 100))
  > activate.edges(anet,   20,  30, e=seq(77, 100))
  > activate.edges(anet,   30,  30, e=seq(77, 100))
  > activate.edges(anet,   40,  50, e=seq(77, 100))
  > activate.edges(anet,   60, Inf, e=seq(77, 100))
  > activate.edges(anet, c(Inf, -Inf, -Inf, -Inf, -Inf, -Inf, -Inf,  20,  25,  30,  35, 20, 20, 20, 30, 20, 30, 30, 30, 15, 15, 15,  0,   0),
  +                      c(Inf,  Inf,   20,   25,   30,   35,   55, Inf, Inf, Inf, Inf, 40, 45, 50, 35, 55, 40, 45, 55, 35, 45, 55, 25,  55),
  +                  e = c( 77,   78,   79,   80,   81,   82,   83,  84,  85,  86,  87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100))
  > dmat0 = matrix(c(-Inf,20,30,40,60,10,30,30,50,Inf),5,2)
  > dmat1 = matrix(c(-Inf,30,40,60,30,30,50,Inf),4,2)
  > dmat2 = matrix(c(-Inf,40,60,35,50,Inf),3,2)
  > dmat3 = matrix(c(-Inf,20,60,10,55,Inf),3,2)
  > dmat4 = matrix(c(-Inf,20,10,Inf),2,2)
  > dmat5 = matrix(c(-Inf,20,30,35,10,30,30,Inf),4,2)
  > dmat6 = matrix(c(-Inf,20,60,10,50,Inf),3,2)
  > dmat7 = matrix(c(-Inf,20,60,10,55,Inf),3,2)
  > dmat8 = matrix(c(-Inf,15,40,60,10,35,50,Inf),4,2)
  > dmat9 = matrix(c(-Inf,15,60,10,50,Inf),3,2)
  > dmat10 = matrix(c(-Inf,15,60,10,55,Inf),3,2)
  > dmat11 = matrix(c(-Inf,20,40,60,10,35,50,Inf),4,2)
  > dmat12 = matrix(c(-Inf,60,55,Inf),2,2)
  > 
  > d77 = identical(anet$mel[[77]]$atl$active, dmat0)    # add (Inf, Inf)   to set of spells
  > d78 = identical(anet$mel[[78]]$atl$active,           # add (-Inf, Inf)  to set of spells
  +       matrix(c(-Inf, Inf), 1,2))
  > d79 = identical(anet$mel[[79]]$atl$active, dmat1)    # add (-Inf, a2)   to set of spells
  > d80 = identical(anet$mel[[80]]$atl$active, dmat1)    # add (-Inf, M2)   to set of spells
  > d81 = identical(anet$mel[[81]]$atl$active, dmat1)    # add (-Inf, b2)   to set of spells
  > d82 = identical(anet$mel[[82]]$atl$active, dmat2)    # add (-Inf, G23)  to set of spells
  > d83 = identical(anet$mel[[83]]$atl$active, dmat12)   # add (-Inf, G34)  to set of spells
  > d84 = identical(anet$mel[[84]]$atl$active, dmat4)    # add (a2, Inf)    to set of spells
  > d85 = identical(anet$mel[[85]]$atl$active, dmat4)    # add (M2, Inf)    to set of spells
  > d86 = identical(anet$mel[[86]]$atl$active, dmat4)    # add (b2, Inf)    to set of spells
  > d87 = identical(anet$mel[[87]]$atl$active, dmat5)    # add (G23, Inf)   to set of spells
  > d88 = identical(anet$mel[[88]]$atl$active, dmat6)    # add (a2, a3)     to set of spells
  > d89 = identical(anet$mel[[89]]$atl$active, dmat6)    # add (a2, M3)     to set of spells
  > d90 = identical(anet$mel[[90]]$atl$active, dmat6)    # add (a2, b3)     to set of spells
  > d91 = identical(anet$mel[[91]]$atl$active, dmat11)   # add (a2, G23)    to set of spells
  > d92 = identical(anet$mel[[92]]$atl$active, dmat3)    # add (a2, G34)    to set of spells
  > d93 = identical(anet$mel[[93]]$atl$active, dmat6)    # add (b2, a3)     to set of spells
  > d94 = identical(anet$mel[[94]]$atl$active, dmat6)    # add (b2, M3)     to set of spells
  > d95 = identical(anet$mel[[95]]$atl$active, dmat7)    # add (b2, G34)    to set of spells
  > d96 = identical(anet$mel[[96]]$atl$active, dmat8)    # add (G12, G23)   to set of spells
  > d97 = identical(anet$mel[[97]]$atl$active, dmat9)    # add (G12, M3)    to set of spells
  > d98 = identical(anet$mel[[98]]$atl$active, dmat10)   # add (G12, G34)   to set of spells
  > d99 = identical(anet$mel[[99]]$atl$active, dmat1)    # add (M1, M2)     to set of spells
  > d100 = identical(anet$mel[[100]]$atl$active, dmat12) # add (M1, G34)    to set of spells
  > 
  >                
  > d.tests = paste("d", seq(1,94), sep="")
  > d.results= sapply(d.tests, function(x){eval(parse(text=x))})
  > if(any(!d.results)){
  +   bad.tests = paste("d", which(!d.results), sep="", collapse=" ")
  +   stop(paste("activate.edges is incorrectly activating edges in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # other tests for 'activate.edges'
  > anet <- anet.copy
  > mat0=matrix(c(-Inf, Inf),1,2)
  > # default behavior
  > activate.edges(anet, e=1)                     # no inputs, no activity matrix
  > e1 = identical(anet$mel[[1]]$atl$active,mat0)
  > activate.edges(anet, 3, 10, e=2)               # no inputs, activity matrix
  > activate.edges(anet, e=2)                     
  > e2 = identical(anet$mel[[2]]$atl$active,mat0)
  > anet$mel[[3]]$atl$active <- matrix(c(Inf,Inf), 1,2) # no inputs, matrix of null spell
  > activate.edges(anet, e=3) 
  > e3 = identical(anet$mel[[3]]$atl$active,mat0)
  > #activate.edges(anet, e=2, onset=3)            # only onset
  > #e2 = identical(anet$mel[[2]]$atl$active,
  > #  matrix(c(3, Inf),1,2))
  > #activate.edges(anet, e=3, terminus=3)         # only terminus
  > #e3 = identical(anet$mel[[3]]$atl$active,
  > #  matrix(c(-Inf, 3),1,2))
  > # ignoring 'null' spells
  > activate.edges(anet, Inf, Inf, e=4)          # single call (Inf, Inf)
  > e4 = is.null(anet$mel[[4]]$atl$active)
  > activate.edges(anet, -Inf, -Inf, e=5)        # single call (-Inf, -Inf)
  > e5 = is.null(anet$mel[[5]]$atl$active)
  > activate.edges(anet, c(-Inf, -Inf, -Inf,  3, Inf), # mixed call, even lengths
  +                      c( Inf, -Inf,  10, Inf, Inf),
  +                      e=seq(6,10))
  > e6 = is.null(anet$mel[[7]]$atl$active) &
  +      is.null(anet$mel[[10]]$atl$active)
  > activate.edges(anet, c(-Inf, -Inf, Inf),     # mixed call, uneven lengths
  +                      c( Inf, -Inf),
  +                      e=seq(11,14))
  > e7 = identical(anet$mel[[11]]$atl$active,
  +         matrix(c(-Inf, Inf),1,2)) &&
  +      is.null(anet$mel[[12]]$atl$active) &&
  +      is.null(anet$mel[[13]]$atl$active) &&
  +      is.null(anet$mel[[14]]$atl$active)
  > 
  > e.tests = paste("e", seq(1,7), sep="")
  > e.results= sapply(e.tests, function(x){eval(parse(text=x))})
  > if(any(!e.results)){
  +   bad.tests = paste("e", which(!e.results), sep="", collapse=" ")
  +   stop(paste("activate.edges is incorrectly activating edges in tests",
  +              bad.tests))
  + }
  > # using 'at' rather than 'onset' and 'terminus'
  > activate.edges(anet, -Inf,  10, e=seq(15, 24))
  > activate.edges(anet,   20,  30, e=seq(15, 24))
  > activate.edges(anet,   40, Inf, e=seq(15, 24))
  > activate.edges(anet, c(Inf, -Inf, 20, 30, 25), c(Inf, -Inf, 20, 30, 25), e=15:19)
  > activate.edges(anet, at=c(Inf, -Inf, 20, 30, 25), e=20:24)
  > f1 = identical(anet$mel[[15]]$atl$active, anet$mel[[20]]$atl$active)
  > f2 = identical(anet$mel[[16]]$atl$active, anet$mel[[21]]$atl$active)
  > f3 = identical(anet$mel[[17]]$atl$active, anet$mel[[22]]$atl$active)
  > f4 = identical(anet$mel[[18]]$atl$active, anet$mel[[23]]$atl$active)
  > f5 = identical(anet$mel[[19]]$atl$active, anet$mel[[24]]$atl$active)
  > # or 'length' rather than 'terminus'
  > activate.edges(anet, -Inf,  10, e=seq(25, 43))
  > activate.edges(anet,   20,  30, e=seq(25, 43))
  > activate.edges(anet,   40, Inf, e=seq(25, 43))
  > activate.edges(anet, c(15, 15, 15, 15, 15, 20, 20, 20, 20),
  +                      c(18, 20, 25, 30, 35, 25, 30, 35, 40),
  +                    e=c(25, 26, 27, 28, 29, 30, 31, 32, 33))
  > activate.edges(anet, c(15, 15, 15, 15, 15, 20, 20, 20, 20),
  +              length =c( 3,  5, 10, 15, 20,  5, 10, 15, 20),
  +                   e =c(35, 36, 37, 38, 39, 40, 41, 42, 43))
  > f6  = identical(anet$mel[[25]]$atl$active, anet$mel[[35]]$atl$active)
  > f7  = identical(anet$mel[[26]]$atl$active, anet$mel[[36]]$atl$active)
  > f8  = identical(anet$mel[[27]]$atl$active, anet$mel[[37]]$atl$active)
  > f9  = identical(anet$mel[[28]]$atl$active, anet$mel[[38]]$atl$active)
  > f10 = identical(anet$mel[[29]]$atl$active, anet$mel[[39]]$atl$active)
  > f11 = identical(anet$mel[[30]]$atl$active, anet$mel[[40]]$atl$active)
  > f12 = identical(anet$mel[[31]]$atl$active, anet$mel[[41]]$atl$active)
  > f13 = identical(anet$mel[[32]]$atl$active, anet$mel[[42]]$atl$active)
  > f14 = identical(anet$mel[[33]]$atl$active, anet$mel[[43]]$atl$active)
  > # possible oddities around inclusion of instantaneous points
  > activate.edges(anet, 10, 20, e=44:48)
  > activate.edges(anet, at=20, e=44:48)
  > activate.edges(anet, at=30, e=46:48)
  > activate.edges(anet, at=10, e=49:50)
  > activate.edges(anet, at=20, e=49:50)
  > activate.edges(anet, at=30, e=50)
  >                
  > activate.edges(anet, 20, 30, e=44)
  > f15 = identical(anet$mel[[44]]$atl$active,
  +         matrix(c(10, 30),1,2))
  > activate.edges(anet, 15, 30, e=45)
  > f16 = identical(anet$mel[[45]]$atl$active,
  +         matrix(c(10, 30),1,2))
  > activate.edges(anet, 20, 30, e=46)
  > f17 = identical(anet$mel[[46]]$atl$active,
  +         matrix(c(10,30,30,30),2,2))
  > activate.edges(anet, 20, 40, e=47)
  > f18 = identical(anet$mel[[47]]$atl$active,
  +         matrix(c(10, 40),1,2))
  > activate.edges(anet, 30, 40, e=48)
  > f19 = identical(anet$mel[[48]]$atl$active,
  +         matrix(c(10,20,30,20,20,40),3,2))
  > activate.edges(anet, 20,20, e=49)
  > f20 = identical(anet$mel[[49]]$atl$active,
  +         matrix(c(10,20,10,20),2,2))
  > activate.edges(anet, 20,20, e=50)               
  > f21 = identical(anet$mel[[50]]$atl$active,
  +         matrix(c(10,20,30,10,20,30),3,2))
  >                
  > f.tests = paste("f", seq(1,21), sep="")
  > f.results= sapply(f.tests, function(x){eval(parse(text=x))})
  > if(any(!f.results)){
  +   bad.tests = paste("f", which(!f.results), sep="", collapse=" ")
  +   stop(paste("activate.edges is incorrectly activating edges in tests",
  +              bad.tests))
  + }
  > 
  > # no edges, so should do nothing (but not crash)
  > expect_equal(network.edgecount(activate.edges(network.initialize(0))),0)
  Error in expect_equal(network.edgecount(activate.edges(network.initialize(0))),  : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/age.at_tests.R’ failed.
Complete output:
  > # tests for age.at functions
  > library(networkDynamic)
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > library(testthat)
  Error in library(testthat) : there is no package called 'testthat'
  Execution halted
Running the tests in ‘tests/classTests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > # tests to determine if the networkDynamic class is being set appropriately tested for
  > 
  > library(networkDynamic)
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > #check if activate.edge sets class.
  > net <- network.initialize(5)
  > net[1,2] <-1
  > nD <-activate.edges(net,onset=0,terminus=1)
  > if (!is.networkDynamic(nD)){
  +   stop("activate edges did not set networkDynamic class")
  + }
  > nd <- NULL
  > 
  > net <- network.initialize(5)
  > net[1,2] <-1
  > nD <-activate.vertices(net,onset=0,terminus=1)
  > if (!is.networkDynamic(nD)){
  +   stop("activate vertices did not set networkDynamic class")
  + }
  > 
  > expect_true(is.networkDynamic(as.networkDynamic(network.initialize(0))))
  Error in expect_true(is.networkDynamic(as.networkDynamic(network.initialize(0)))) : 
    could not find function "expect_true"
  Execution halted
Running the tests in ‘tests/converter_tests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > #test networkDynamic conversion functionality
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > 
  > # ------ get.vertex.activity test ------
  > 
  > net<-network.initialize(5)
  > activate.vertices(net,onset=c(1,2,3,-Inf,100),terminus=c(10,20,Inf,30,Inf))
  > activate.vertices(net,at=1000)
  > expect_equal(unlist(get.vertex.activity(net)),c(1,1000,10,1000,2,1000,20,1000,3,Inf,-Inf,1000,30,1000,100,Inf),info='check if spell list has correct elements in get.vertex.activity')
  Error in expect_equal(unlist(get.vertex.activity(net)), c(1, 1000, 10,  : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/get_tests.R’ failed.
Complete output:
  > ########################################################################
  > # This file contains the testing suite for the "get" methods, i.e.:
  > #      get.edgeIDs.active
  > #      get.edges.active
  > #      get.neighborhood.active     
  > #      get.change.times
  > #########################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > #---------------- GET.CHANGE.TIMES TESTS ------------------------
  > # Notes:
  > #  -- minimal level of testing done here. sorry -- alc 6/28/12
  > #-------------------------------------------------------------------
  > 
  > cat("testing get.change.times ... ")
  testing get.change.times ... > 
  > # a case with no change times
  > data(flo)
  > net1 = network(flo)
  > t1 = get.change.times(net1)
  > a1 = (length(t1) == 0)
  > 
  > # a case with only edge change times
  > activate.edges(net1, onset=1:20, terminus=101:120)
  > t2 = get.change.times(net1, edge.activity=F)
  > t3 = get.change.times(net1)
  > a2 = (length(t2) == 0)
  > a3 = all(t3==c(1:20, 101:120))
  > 
  > # a case with only vertex change times
  > net2 = network(flo)
  > activate.vertices(net2, at=seq(2,32,2))
  > t4 = get.change.times(net2, vertex.activity=F)
  > t5 = get.change.times(net2)
  > a4 = (length(t4) == 0)
  > a5 = all(t5 == seq(2,32,2))
  > 
  > # a case with both types of change times
  > activate.edges(net2, at=60:99)
  > t6 = get.change.times(net2, vertex.activity = F)
  > t7 = get.change.times(net2, edge.activity = F)
  > t8 = get.change.times(net2)
  > a6 = all(t6 == 60:99)
  > a7 = all(t7 == seq(2,32,2))
  > a8 = all(t8 == c(seq(2,32,2), 60:99))
  > 
  > # a case with infinity
  > deactivate.edges(net1)
  > activate.edges(net2)
  > t9 = get.change.times(net1)
  > t10 = get.change.times(net2)
  > t11 = get.change.times(net1, ignore.inf=F)
  > t12 = get.change.times(net2, ignore.inf=F)
  > a9 = (length(t9) == 0)
  > a10 = all(t10 == seq(2,32,2))
  > a11 = length(t11)==0
  > a12 = all(t12 == c(-Inf,seq(2,32,2),Inf))
  > a.tests = paste("a", seq(1,12), sep="")
  > a.results= sapply(a.tests, function(x){eval(parse(text=x))})
  > if(any(!a.results)){
  +   bad.tests = paste("a", which(!a.results), sep="", collapse=" ")
  +   stop(paste("get.change.times is returning incorrect times in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # test when called on a nD with no edge times
  > 
  > # test vertex attributes stuff
  > net<-network.initialize(5)
  > activate.vertex.attribute(net,"number","one",onset=0,terminus=2)
  > activate.vertex.attribute(net,"number","two",onset=3,terminus=4)
  > activate.vertex.attribute(net,"number","three",onset=5,terminus=6)
  > 
  > expect_equal(get.change.times(net),c(0,2,3,4,5,6))
  Error in expect_equal(get.change.times(net), c(0, 2, 3, 4, 5, 6)) : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/import_tests.R’ failed.
Complete output:
  > # tests of file importing in various formats
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > pkgpath<-path.package('networkDynamic') # for accessing test files
  > # below is a work around for local-specific sort order bug in R CMD check 
  > # that causes order of attributes in the list to be sorted differently
  > Sys.setlocale("LC_COLLATE", "C")
  [1] "C"
  > 
  > 
  > # ----- read.son import tests ---
  > # try reading basic file containing alpha ids and with start time but no end time
  > # also includes a fake cluster, just to mess with things
  > test_that("file with alphaIds",{
  +   expect_warning(alphaIdNet<-read.son(paste(pkgpath,'/extdata/alphaIdTest.son',sep='')),regexp="Unable to locate an arc column for 'EndTime'")
  +   expect_equal(as.data.frame(alphaIdNet)$onset,c(0,0))
  +   expect_equal(as.data.frame(alphaIdNet)$terminus,c(0,0))
  +   expect_equal(as.data.frame(alphaIdNet)$tail,c(1,3))
  +   expect_equal(as.data.frame(alphaIdNet)$head,c(2,2))
  +   # did it load pid
  +   expect_equal(alphaIdNet%n%'vertex.pid','vertex.names')
  +   expect_equal(alphaIdNet%v%'vertex.names',c('1','2','three'))
  + })
  Error in test_that("file with alphaIds", { : 
    could not find function "test_that"
  Execution halted
Running the tests in ‘tests/network_tests.R’ failed.
Complete output:
  > ########################################################################
  > # This file contains the testing suite for the "network" methods, i.e.:
  > #
  > #   network.extract              network.edgecount.active
  > #   network.dynamic.check        network.naedgecount.active
  > #   network.dyadcount.active     network.size.active   
  > #########################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat) # helper package for unit tests
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > 
  > #------------------------ NETWORK.EXTRACT ----------------------------
  > # Notes:
  > #  - I've tested combinations of retain.all.vertices with bipartite
  > #    and non-bipartite networks, directed and undirected networks,
  > #    networks w/ and w/o loops or multi-edges.  I have not tested
  > #    what would happen if users added onto the basic network structure,
  > #    or what happens if edges/nodes are missing.
  > #--------------------------------------------------------------------
  > 
  > cat("testing network.extract ... ")
  testing network.extract ... > 
  > # a network with no active anything and no edges
  > anet0 <- network.initialize(7, directed=FALSE)
  > bnet0=network.extract(anet0, at=10)
  > b0 = (bnet0%n%"n" == 7)
  > # a network with no active anything
  > anet1 <- network.initialize(7, directed=FALSE)
  > add.edges(anet1, c(1,2,3,4,4,4),
  +                  c(2,4,4,6,7,5))
  > anet.copy <- anet1
  > deactivate.edges(anet1)
  > deactivate.vertices(anet1)
  > bnet1=network.extract(anet1, at=10)
  > bnet1.t=anet1%t%10
  > b1 = all.equal(bnet1, as.networkDynamic(network.initialize(0,directed=FALSE)))
  > b2 = identical(bnet1, bnet1.t)
  > # a network with no active edges, but active vertices, retain.all=F
  > anet2 <- anet.copy
  > activate.vertices(anet2, 10, 20, v=c(1,3,4))
  > deactivate.vertices(anet2, v=c(2,4,5,7))
  > deactivate.edges(anet2)
  > bnet2=network.extract(anet2, at=10)
  > bnet2.t=anet2%t%10
  > b2 = (bnet2%n%"n" == 3)
  > b3 = (bnet2%n%"mnext" == 1)
  > b4 = identical(bnet2, bnet2.t)
  > # a network with no active edges, but active vertices, retain.all=T
  > anet3 <- anet2
  > bnet3=network.extract(anet3, at=10, retain.all.vertices=TRUE)
  > b5 = (bnet3%n%"n" == 7)
  > b6 = (bnet3%n%"mnext" == 1)
  > # a network with no active vertices, but active edges
  > anet4 <- anet.copy
  > activate.vertices(anet4, 10, Inf)
  > activate.edges(anet4, -Inf, 20)
  > bnet4=network.extract(anet4, -10, 0)
  > b7 = all.equal(bnet4, as.networkDynamic(network.initialize(0,directed=FALSE)))
  > # networks with active edges and vertices
  > #  a non-bipartite simple network, retain.all=F
  > anet5 <- anet.copy
  > activate.vertices(anet5, 10, 40, v=c(1,3,4,5,7))
  > deactivate.vertices(anet5, v=c(2,6))
  > activate.edges(anet5, at=30, e=c(1,3,4,6))
  > deactivate.edges(anet5, e=c(2,5))
  > bnet5=network.extract(anet5, at=30)
  > bnet5.t=anet5%t%30
  > el5 = as.matrix(bnet5, matrix.type="edgelist")
  > b8 = (bnet5%n%"n" == 5)
  > b9 = (bnet5%n%"mnext" == 3)
  > b10 = all(el5==matrix(c(2,3,3,4),2,2))
  > b11 = identical(bnet5, bnet5.t)
  > #  a non-bipartite simple network, retain.all=T
  > anet6 <- anet5
  > bnet6=network.extract(anet6, at=30, retain.all=TRUE)
  > el6 = as.matrix(bnet6, matrix.type="edgelist")
  > b12 = (bnet6%n%"n" == 7)
  > b13 = (bnet6%n%"mnext" == 3)
  > b14 = all(el6==matrix(c(3,4,4,5),2,2))
  > # bipartite simple network, retain.all = F
  > anet7 <- network.initialize(10, bipartite=6)
  > add.edges(anet7, c(1,2,3,4,4,6), c(7,8,7,8,9,10))
  > activate.vertices(anet7, -Inf, Inf, v=c(1,3,6,7,9,10))
  > activate.edges(anet7, 10, Inf, e=c(1,3,5))
  > bnet7=network.extract(anet7, 0, 20, active.default=FALSE)
  > el7 = as.matrix(bnet7, matrix.type="edgelist")
  > b15 = (bnet7%n%"n" == 6)
  > b16 = (bnet7%n%"mnext" == 3)
  > b17 = (bnet7%n%"bipartite"== 3)
  > b18 = all(el7==matrix(c(1,2,4,4),2,2))
  > # bipartite simple network, retain.all = T
  > anet8 <- anet7
  > bnet8=network.extract(anet8, 0, 20, active.default=FALSE, retain.all.vertices=T)
  > el8 = as.matrix(bnet8, matrix.type="edgelist")
  > b19 = (bnet8%n%"n" == 10)
  > b20 = (bnet8%n%"mnext" == 3)
  > b21 = (bnet8%n%"bipartite"== 6)
  > b22 = all(el8==matrix(c(1,3,7,7),2,2))
  > # a non-bipartite network, with loops, retain.all=F
  > anet9 <- anet.copy
  > add.edges(anet9, c(2,5,6), c(2,5,6))
  > activate.vertices(anet9, v=c(1,2,4,6))
  > deactivate.vertices(anet9, v=c(3,5,7))
  > activate.edges(anet9, e=c(1,2,6,7,8))
  > deactivate.edges(anet9, e=c(3,4,5,9))
  > bnet9=network.extract(anet9, at=-Inf)
  > bnet9.t=anet9%t%-Inf
  > el9 = as.matrix(bnet9, matrix.type="edgelist")
  > b23 = (bnet9%n%"n" == 4)
  > b24 = (bnet9%n%"mnext" == 4)
  > b25 = all(el9==matrix(c(1,2,2,2,3,2),3,2))
  > b26 = identical(bnet9, bnet9.t)
  > # a non-bipartite network, with loops, retain.all=F
  > anet10 <- anet9
  > bnet10=network.extract(anet10, at=Inf, retain.all.vertices=T)
  > el10 = as.matrix(bnet10, matrix.type="edgelist")
  > b27 = (bnet10%n%"n" == 7)
  > b28 = (bnet10%n%"mnext" == 4)
  > b29 = all(el10==matrix(c(1,2,2,2,4,2),3,2))
  > # a non-bipartite network, with multi-edges, retain.all=F
  > anet11 <- network.initialize(8)
  > add.edges(anet11, c(1,1,1,1,1,4,4,5,5,6,6,8),
  +                   c(3,3,3,6,2,2,5,4,8,7,7,5))
  > activate.vertices(anet11, 10,20, v=c(1,3,4,5,6,7))
  > deactivate.vertices(anet11, v=c(2,8))
  > activate.edges(anet11, 10, 15, e=c(1:3,7,9,11))
  > deactivate.edges(anet11, e=c(4,5,6,8,10,12))
  > bnet11=network.extract(anet11, 11,14)
  > el11 = as.matrix(bnet11, matrix.type="edgelist")
  > b30 = (bnet11%n%"n" == 6)
  > b31 = (bnet11%n%"mnext" == 6)
  > b32 = all(el11==matrix(c(1,1,1,3,5,2,2,2,4,6),5,2))
  > # a non-bipartite network, with multi-edges, retain.all=T
  > anet12 <- anet11
  > bnet12=network.extract(anet12, 14,19, retain.all.vertices=T)
  > el12 = as.matrix(bnet12, matrix.type="edgelist")
  > b33 = (bnet12%n%"n" == 8)
  > b34 = (bnet12%n%"mnext" == 6)
  > b35 = all(el12==matrix(c(1,1,1,4,6,3,3,3,5,7),5,2))
  > # pavel's test with nullified edges
  > data(flo)
  > anet13 <- network(flo)
  > anet13[15,] = 0   # remove all out edges from node 15
  > el13 <- as.matrix(anet13, matrix.type="edgelist")
  > deactivate.edges(anet13)
  > activate.edges(anet13, e=seq(2,40,2))
  > bnet13 <- anet13 %t% 5
  > el13.b1 <- el13[c(2,4,6,8,9,seq(12,24,2),seq(28,36,2)),]
  > el13.b2 <- as.matrix(bnet13, matrix.type="edgelist")
  > b36 = (bnet13%n%"n" == 16)
  > b37 = all(el13.b1==el13.b2)
  > 
  > 
  > b.tests = paste("b", seq(0,37), sep="")
  > b.results= sapply(b.tests, function(x){eval(parse(text=x))})
  > if(any(!b.results)){
  +   bad.tests = paste("b", which(!b.results), sep="", collapse=" ")
  +   stop(paste("network.extract is incorrectly extracting networks in tests",
  +              bad.tests))
  + }
  > 
  > nd<-network.initialize(7)
  > add.edges.active(nd,onset=0,terminus=5,tail=1,head=2)
  > add.edges.active(nd,onset=4,terminus=6,tail=2,head=3)
  > add.edges.active(nd,onset=0,terminus=5,tail=3,head=4)
  > add.edges.active(nd,onset=4,terminus=8,tail=4,head=5)
  > activate.edge.attribute(nd,"letters","a",onset=0,terminus=5)
  > activate.vertex.attribute(nd,"numbers","one",onset=0,terminus=5)
  > activate.network.attribute(nd,"squashes","pumpkin",onset=0,terminus=5)
  > nd1<-network.extract(nd,onset=1,terminus=3,trim.spells=TRUE)
  > if(!all(get.change.times(nd1) == c(1,3))){
  +   stop("network.extract did not trim edge activity spells to query range as expected")
  + }
  > if(!all(get.edge.value.active(nd1,"letters",onset=-Inf,terminus=Inf,return.tea=TRUE)[[1]][[2]]==c(1,3))){
  +   stop("network.extract did not trim edge attribute activity spells to query range as expected")
  + }
  > if(!all(get.vertex.attribute.active(nd1,"numbers",onset=-Inf,terminus=Inf,return.tea=TRUE)[[1]][[2]]==c(1,3))){
  +   stop("network.extract did not trim vertex attribute activity spells to query range as expected")
  + }
  > if(!all(get.network.attribute.active(nd1,"squashes",onset=-Inf,terminus=Inf,return.tea=TRUE)[[2]]==c(1,3))){
  +   stop("network.extract did not trim network attribute activity spells to query range as expected")
  + }
  > 
  > # test trim with "at" version
  > nd3<-network.extract(nd,at=3,trim.spells=TRUE)
  > if (!all(nd3$mel[[1]]$atl$letters.active[[2]] == c(3,3), nd3$mel[[1]]$atl$letters.active[[1]]=='a')){
  +   stop("network.extract did not trim edge attribute spells to 'at' query range as expected")
  + }
  > 
  > if (!all(nd3$val[[1]]$numbers.active[[2]] == c(3,3),nd3$val[[1]]$numbers.active[[1]]=='one')){
  +   stop("network.extract did not trim vertex attribute spells to 'at' query range as expected")
  + }
  > 
  > if (!all(nd3$gal$squashes.active[[2]] == c(3,3),nd3$gal$squashes.active[[1]]=='pumpkin')){
  +   stop("network.extract did not trim network attribute spells to 'at' query range as expected")
  + }
  > 
  > if (!all(nd3$mel[[1]]$atl$active==c(3,3))){
  +   stop("network.extract did not trim edge activity spells to 'at' query range as expecrted")
  + }
  > 
  > if (!all(nd3$val[[1]]$active==c(3,3))){
  +   stop("network.extract did not trim vertex activity spells to 'at' query range as expecrted")
  + }
  > 
  > # check that vertices included by retain.all=TRUE are marked inactive
  > net<-network.initialize(3)
  > activate.vertices(net,onset=0,terminus=2,v=2:3)
  > net1<-network.extract(net,at=1,active.default=FALSE,retain.all.vertices=TRUE,trim.spells=TRUE)
  > expect_true(is.null(get.vertex.activity(net1)[[1]]),info="check that vertices included by retain.all=TRUE are marked inactive by trim.spells")
  Error in expect_true(is.null(get.vertex.activity(net1)[[1]]), info = "check that vertices included by retain.all=TRUE are marked inactive by trim.spells") : 
    could not find function "expect_true"
  Execution halted
Running the tests in ‘tests/pid_tests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > #Create a network with three edges
  > m<-matrix(0,3,3)
  > m[1,2]<-1; m[2,3]<-1; m[3,1]<-1
  > g<-network(m)
  > 
  > #Create a matrix of values corresponding to edges
  > mm<-m
  > mm[1,2]<-7; mm[2,3]<-4; mm[3,1]<-2
  > 
  > #Assign some attributes
  > set.edge.attribute(g,"myeval",3:5)
  > set.edge.value(g,"myeval2",mm)
  > set.network.attribute(g,"mygval","boo")
  > set.vertex.attribute(g,"myvval",letters[1:3])
  > network.vertex.names(g) <- LETTERS[1:10]
  > 
  > set.network.attribute(g, 'vertex.pid', 'vertex.names')
  > 
  > 
  > # check if some pid missing
  > 
  > #------ get.vertex.id checks ------
  > 
  > expect_equal(get.vertex.id(g, 'A'),1)
  Error in expect_equal(get.vertex.id(g, "A"), 1) : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/query_tests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > ########################################################################
  > # This file contains the testing suite for the "query" methods, i.e.:
  > #     is.active
  > #     is.adjacent.active
  > #########################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > 
  > #-------------------- IS.ACTIVE TESTS ---------------------------------
  > # Notes:
  > #  -these are meant to be exhaustive except where noted otherwise
  > #  -the list named "spells" created below is helpful for checking
  > #   that the tests are correctly written
  > #  -for understanding the comments, let
  > #      L=finite number lower than spell boundary,
  > #      H=finite number higher than spell boundary,
  > #      M=finite number within a spell boundary
  > #----------------------------------------------------------------------
  > 
  > # create a test network
  > anet <- network.initialize(100)
  > set.seed(10)
  > heads <- sample(100, 150, replace=TRUE)
  > set.seed(25)
  > tails <- sample(100, 150, replace=TRUE)
  > add.edges(anet, tails, heads)
  > anet.copy <- anet
  > 
  > cat("testing is.active ... ")
  testing is.active ... > 
  > # proper behavior for bad inputs?  (not exhaustive)
  > #  -- bad network input
  > a1 = try(is.active(3, 3, 3), T)                  # properly handeled
  > #  -- bad onset
  > a2 = try(is.active(anet, "a", 3), T)             # properly handeled
  > a3 = try(is.active(anet, NULL, 3), T)            # properly handeled
  > # -- bad terminus
  > a4 = try(is.active(anet, 3, "b"), T)             # properly handeled
  > # -- bad edges
  > a5 = try(is.active(anet, 3, 10, e=224), T)       # properly handeled     
  > a6 = try(is.active(anet, 3, 10, e=-2), T)        # properly handeled    
  > a7 = try(is.active(anet, 3, 10, e=NULL), T)      # properly handeled    
  > # -- bad vertices
  > a8 = try(is.active(anet, 3, 10, v=224), T)       # properly handeled     
  > a9 = try(is.active(anet, 3, 10, v=-2), T)        # properly handeled    
  > # -- bad rule
  > a10 = try(is.active(anet, 3, 20, e=1, rule=10), T)   # properly handeled by R
  > a11 = try(is.active(anet, 15, 25, e=5, rule=c("all", "any")), T)  # properly handeled by R
  > # -- bad active.default
  > a12 = try(is.active(anet, 3, 10, e=1, active.default=4), T)   # returns 4
  > # -- bad onset & terminus combo
  > a13 = try(is.active(anet, 10, 3, e=5), T)        # properly handeled
  > # -- bad edges & vertices combo
  > a14 = try(is.active(anet, 3, 10, e=5, v=4), T)   # properly handeled
  > 
  > 
  > # now, for completely valid input ...
  > activate.edges(anet, c(-Inf, -Inf,  10, 10, 10),
  +                      c( Inf,   20, Inf, 20, 10), e=2:6)
  > activate.edges(anet, 10, 20, e=7)
  > activate.edges(anet, 20, 30, e=7)
  > activate.edges(anet, 30, 30, e=7)
  > activate.edges(anet, 40, 50, e=7)
  > deactivate.edges(anet, e=8)
  > spells = lapply(lapply(anet$mel[1:8],"[[","atl"),"[[","active")
  >   
  > # point queries that should be TRUE
  > b1  = is.active(anet, at=4, e= 1)      # for any &      NULL  
  > b2  = is.active(anet, at=3, e= 2)      # for M &     (-Inf, Inf)
  > b3  = is.active(anet, at=-Inf, e= 2)   # for -Inf &  (-Inf, Inf)
  > b4  = is.active(anet, at=Inf, e= 2)    # for Inf &   (-Inf, Inf)
  > b5  = is.active(anet, at=5, e=3)       # for M &     (-Inf, b)
  > b6  = is.active(anet, at=15, e=7)      # for M &     (-Inf, b)
  > b7  = is.active(anet, at=-Inf, e=3)    # for -Inf &  (-Inf, b)
  > b8  = is.active(anet, at=50, e=4)      # for M &     (a, Inf)
  > b9 = is.active(anet, at=45, e=7)       # for M &     (a, Inf)
  > b10 = is.active(anet, at=10, e=4)      # for a &     (a, Inf)
  > b11 = is.active(anet, at=20, e=7)      # for a &     (a, Inf)
  > b12 = is.active(anet, at=Inf, e=4)     # for Inf &   (a, Inf)
  > b13 = is.active(anet, at=15, e=4)      # for M &     (a, b)
  > b14 = is.active(anet, at=25, e=7)      # for M &     (a, b)
  > b15 = is.active(anet, at=10, e=4)      # for a &     (a, b)
  > b16 = is.active(anet, at=20, e=7)      # for a &     (a, b)
  > b17 = is.active(anet, at=10, e=6)      # for a &     (a, a)
  > b18 = is.active(anet, at=30, e=7)      # for a &     (a, a)
  > 
  > b.tests = paste("b", seq(1,18), sep="")
  > b.results= sapply(b.tests, function(x){eval(parse(text=x))})
  > if(any(!b.results)){
  +   bad.tests = paste("b", which(!b.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper FALSE values in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # point queries that should be FALSE
  > c1  = is.active(anet, at=4, e=1,active.default=F)  # for any & NULL
  > c2  = is.active(anet, at=3, e=8)       # for 'never active' NULL spell
  > c3  = is.active(anet, at=25, e=3)      # for H &    (-Inf, b)
  > c4  = is.active(anet, at=55, e=7)      # for H &    (-Inf, b)
  > c5  = is.active(anet, at=20, e=3)      # for b &    (-Inf, b)
  > c6  = is.active(anet, at=50, e=7)      # for b &    (-Inf, b)
  > c7  = is.active(anet, at=Inf, e=3)     # for Inf &  (-Inf, b)
  > c8  = is.active(anet, at=5, e=4)       # for L &    (a, Inf)
  > c9  = is.active(anet, at=35, e=7)      # for L &    (a, Inf)
  > c10 = is.active(anet, at=-Inf, e=4)    # for -Inf & (a, Inf)
  > c11 = is.active(anet, at=5, e=5)       # for L &    (a, b)
  > c12 = is.active(anet, at=5, e=7)       # for L &    (a, b)
  > c13 = is.active(anet, at=25, e=5)      # for H &    (a, b)
  > c14 = is.active(anet, at=55, e=7)      # for H &    (a, b)
  > c15 = is.active(anet, at=20, e=5)      # for b &    (a, b)
  > c16 = is.active(anet, at=50, e=7)      # for b &    (a, b)
  > c17 = is.active(anet, at=0, e=6)       # for L &    (a, a)
  > 
  > c.tests = paste("c", seq(1,17), sep="")
  > c.results= sapply(c.tests, function(x){eval(parse(text=x))})
  > if(any(c.results)){
  +   bad.tests = paste("c", which(c.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper TRUE values in tests",
  +              bad.tests))
  + }
  > 
  > # interval queries that should be TRUE using 'rule=all'
  > d1  = is.active(anet, 4, 5, e= 1, rule='all')       # for any &           NULL
  > d2  = is.active(anet, -Inf, Inf, e= 1, rule='all')  # for any &           NULL  
  > d3  = is.active(anet, -Inf, Inf, e= 2, rule='all')  # for (-Inf,Inf) & (-Inf, Inf)
  > d4  = is.active(anet, -Inf, -Inf, e= 2, rule='all') # for (-Inf,-Inf)& (-Inf, Inf)
  > d5  = is.active(anet, Inf, Inf, e= 2, rule='all')   # for (Inf,Inf) &  (-Inf, Inf)
  > d6  = is.active(anet, 0, Inf, e= 2, rule='all')     # for (M,Inf) &    (-Inf, Inf)
  > d7  = is.active(anet, -Inf, 0, e= 2, rule='all')    # for (-Inf,M) &   (-Inf, Inf)
  > d8  = is.active(anet, 0, 0, e= 2, rule='all')       # for (M,M) &      (-Inf, Inf)
  > d9  = is.active(anet, 0, 10, e= 2, rule='all')      # for (M,M) &      (-Inf, Inf)
  > d10 = is.active(anet, -Inf, -Inf, e=3, rule='all')  # for (-Inf,-Inf)& (-Inf, b)
  > d11 = is.active(anet, -Inf, 20, e=3, rule='all')    # for (-Inf,b) &   (-Inf, b)
  > d12  = is.active(anet, -Inf, 0, e=3, rule='all')    # for (-Inf,M) &   (-Inf, b)
  > d13 = is.active(anet, -5, 0, e=3, rule='all')       # for (M,M) &      (-Inf, b)
  > d14 = is.active(anet, 0, 20, e=3, rule='all')       # for (M,b) &      (-Inf, b)
  > d15 = is.active(anet, Inf, Inf, e=4, rule='all')    # for (Inf,Inf) &  (a, Inf)
  > d16 = is.active(anet, 10, Inf, e=4, rule='all')     # for (a,Inf) &    (a, Inf)
  > d17 = is.active(anet, 30, Inf, e=4, rule='all')     # for (M,Inf) &    (a, Inf)
  > d18 = is.active(anet, 10, 30, e=4, rule='all')      # for (a,M) &      (a, Inf)
  > d19 = is.active(anet, 30, 40, e=4, rule='all')      # for (M,M) &      (a, Inf)
  > d20 = is.active(anet, 10, 20, e=5, rule='all')      # for (a,b) &      (a, b)
  > d21 = is.active(anet, 10, 15, e=5, rule='all')      # for (a,M) &      (a, b)
  > d22 = is.active(anet, 15, 20, e=5, rule='all')      # for (M,b) &      (a, b)
  > d23 = is.active(anet, 10, 10, e=6, rule='all')      # for (a,a) &      (a, a)
  > 
  > d.tests = paste("d", seq(1,23), sep="")
  > d.results= sapply(d.tests, function(x){eval(parse(text=x))})
  > if(any(!d.results)){
  +   bad.tests = paste("d", which(!d.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper FALSE values in tests",
  +              bad.tests))
  + }
  > 
  > 
  > 
  > # interval queries that should be TRUE using default 'rule=any'
  > e1  = is.active(anet, 4, 5, e= 1)       # for any &           NULL
  > e2  = is.active(anet, -Inf, Inf, e= 1)  # for any &           NULL  
  > e3  = is.active(anet, -Inf, Inf, e= 2)  # for (-Inf,Inf) & (-Inf, Inf)
  > e4  = is.active(anet, -Inf, -Inf, e=2)  # for (-Inf,-Inf)& (-Inf, Inf)
  > e5  = is.active(anet, Inf, Inf, e= 2)   # for (Inf,Inf) &  (-Inf, Inf)
  > e6  = is.active(anet, 0, Inf, e= 2)     # for (M,Inf) &    (-Inf, Inf)
  > e7  = is.active(anet, -Inf, 0, e= 2)    # for (-Inf,M) &   (-Inf, Inf)
  > e8  = is.active(anet, 0, 10, e= 2)      # for (M,M) &      (-Inf, Inf)
  > e9  = is.active(anet, -Inf, -Inf, e=3)  # for (-Inf,-Inf)& (-Inf, b)
  > e10 = is.active(anet, -Inf, 20, e=3)    # for (-Inf,b) &   (-Inf, b)
  > e11 = is.active(anet, -Inf, 10, e=3)    # for (-Inf,M) &   (-Inf, b)
  > e12 = is.active(anet, -Inf, 30, e=3)    # for (-Inf,H) &   (-Inf, b)
  > e13 = is.active(anet, 0, 20, e=3)       # for (M,b) &      (-Inf, b)
  > e14 = is.active(anet, 0, 10, e=3)       # for (M,M) &      (-Inf, b)
  > e15 = is.active(anet, 0, 30, e=3)       # for (M,H) &      (-Inf, b)
  > e16 = is.active(anet, Inf, Inf, e=4)    # for (Inf,Inf) &  (a, Inf)
  > e17 = is.active(anet, 10, Inf, e=4)     # for (a,Inf) &    (a, Inf)
  > e18 = is.active(anet, 20, Inf, e=4)     # for (M,Inf) &    (a, Inf)
  > e19 = is.active(anet, 0, Inf, e=4)      # for (L,Inf) &    (a, Inf)
  > e20 = is.active(anet, 10, 20, e=4)      # for (a,M) &      (a, Inf)
  > e21 = is.active(anet, 0, 20, e=4)       # for (L,M) &      (a, Inf)
  > e22 = is.active(anet, 20, 30, e=4)      # for (M,M) &      (a, Inf)
  > e23 = is.active(anet, -Inf, Inf, e=5)   # for (-Inf, Inf) & (a, b)
  > e24 = is.active(anet,  0, Inf, e=5)     # for (L, Inf) &    (a, b)
  > e25 = is.active(anet, 10, Inf, e=5)     # for (a, Inf) &    (a, b)
  > e26 = is.active(anet, 15, Inf, e=5)     # for (M, Inf) &    (a, b)
  > e27 = is.active(anet, -Inf, 30, e=5)    # for (-Inf, H) &   (a, b)
  > e28 = is.active(anet, -Inf, 20, e=5)    # for (-Inf, b) &   (a, b)
  > e29 = is.active(anet, -Inf, 15, e=5)    # for (-Inf, M) &   (a, b)
  > e30 = is.active(anet, 10, 20, e=5)      # for (a,b) &       (a, b)
  > e31 = is.active(anet, 10, 30, e=5)      # for (a,H) &       (a, b)
  > e32 = is.active(anet, 10, 15, e=5)      # for (a,M) &       (a, b)
  > e33 = is.active(anet, 0, 20, e=5)       # for (L,b) &       (a, b)
  > e34 = is.active(anet, 15, 20, e=5)      # for (M,b) &       (a, b)
  > e35 = is.active(anet, 0, 30, e=5)       # for (L,H) &       (a, b)
  > e36 = is.active(anet, 0, 15, e=5)       # for (L,M) &       (a, b)
  > e37 = is.active(anet, 15, 30, e=5)      # for (M,H) &       (a, b)
  > e38 = is.active(anet, 15, 18, e=5)      # for (M,M) &       (a, b)
  > e39 = is.active(anet, -Inf, Inf, e=6)   # for (-Inf,Inf) &  (a, a)
  > e40 = is.active(anet, 0, Inf, e=6)      # for (L,Inf) &     (a, a)
  > e41 = is.active(anet, -Inf, 20, e=6)    # for (-Inf,H) &    (a, a)
  > e42 = is.active(anet, 10, 20, e=6)      # for (a, H) &      (a, a)
  > e43 = is.active(anet, 30, 35, e=7)      # for (a, H) &      (a, a)
  > e44 = is.active(anet, 10, 10, e=6)      # for (a, a) &      (a, a)
  > e45 = is.active(anet, 0, 20, e=6)       # for (L,H) &       (a, a)
  > 
  > e.tests = paste("e", seq(1,45), sep="")
  > e.results= sapply(e.tests, function(x){eval(parse(text=x))})
  > if(any(!e.results)){
  +   bad.tests = paste("e", which(!e.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper FALSE values in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # interval queries that should be FALSE using 'rule=all'
  > f1  = is.active(anet, 4, 5, e= 1, rule='all', active.default=F)       # for any & NULL
  > f2  = is.active(anet, -Inf, Inf, e= 1, rule='all', active.default=F)  # for any & NULL  
  > f3  = is.active(anet, 3, 5, e= 8, rule= 'all')      # for 'never active' NULL spell
  > f4  = is.active(anet, -Inf, Inf, e= 8, rule= 'all') # for 'never active' NULL spell
  > f5  = is.active(anet, -Inf, Inf, e=3, rule='all')   # for (-Inf,Inf) & (-Inf, b)
  > f6  = is.active(anet, -Inf, 30, e=3, rule='all')    # for (-Inf,H) &   (-Inf, b)
  > f7 = is.active(anet, 0, 30, e=3, rule='all')        # for (M,H) &      (-Inf, b)
  > f8 = is.active(anet, 30, 40, e=3, rule='all')       # for (H,H) &      (-Inf, b)
  > f9 = is.active(anet, -Inf, Inf, e=4, rule='all')    # for (-Inf,Inf) & (a, Inf)
  > f10 = is.active(anet, 0, Inf, e=4, rule='all')      # for (L,Inf) &    (a, Inf)
  > f11 = is.active(anet, 0, 20, e=4, rule='all')       # for (L,M) &      (a, Inf)
  > f12 = is.active(anet, 0, 5, e=4, rule='all')        # for (L,L) &      (a, Inf)
  > f13 = is.active(anet, -Inf, Inf, e=5, rule='all')   # for (-Inf,Inf) & (a, b)
  > f14 = is.active(anet, -Inf, 0, e=5, rule='all')     # for (-Inf,L) &   (a, b)
  > f15 = is.active(anet, -Inf, 10, e=5, rule='all')    # for (-Inf,a) &   (a, b)
  > f16 = is.active(anet, -Inf, 15, e=5, rule='all')    # for (-Inf,M) &   (a, b)
  > f17 = is.active(anet, -Inf, 20, e=5, rule='all')    # for (-Inf,b) &   (a, b)
  > f18 = is.active(anet, -Inf, 30, e=5, rule='all')    # for (-Inf,H) &   (a, b)
  > f19 = is.active(anet, 0, Inf, e=5, rule='all')      # for (L,Inf) &    (a, b)
  > f20 = is.active(anet, 10, Inf, e=5, rule='all')     # for (a,Inf) &    (a, b)
  > f21 = is.active(anet, 15, Inf, e=5, rule='all')     # for (M,Inf) &    (a, b)
  > f22 = is.active(anet, 20, Inf, e=5, rule='all')     # for (b,Inf) &    (a, b)
  > f23 = is.active(anet, 30, Inf, e=5, rule='all')     # for (H,Inf) &    (a, b)
  > f24 = is.active(anet, 10, 30, e=5, rule='all')      # for (a,H) &      (a, b)
  > f25 = is.active(anet,  0, 10, e=5, rule='all')      # for (L,a) &      (a, b)
  > f26 = is.active(anet,  0, 20, e=5, rule='all')      # for (L,b) &      (a, b)
  > f27 = is.active(anet, 20, 30, e=5, rule='all')      # for (b,H) &      (a, b)
  > f28 = is.active(anet,  0, 15, e=5, rule='all')      # for (L,M) &      (a, b)
  > f29 = is.active(anet, 15, 30, e=5, rule='all')      # for (M,H) &      (a, b)
  > f30 = is.active(anet,  0, 30, e=5, rule='all')      # for (L,H) &      (a, b)
  > f31 = is.active(anet, -5,  5, e=5, rule='all')      # for (L,L) &      (a, b)
  > f32 = is.active(anet, 30, 40, e=5, rule='all')      # for (H,H) &      (a, b)
  > f33 = is.active(anet, -Inf,Inf, e=6, rule='all')    # for (-Inf,Inf) & (a, a)
  > f34 = is.active(anet, -Inf, 0, e=6, rule='all')     # for (-Inf,L) &   (a, a)
  > f35 = is.active(anet, -Inf, 10, e=6, rule='all')    # for (-Inf,a) &   (a, a)
  > f36 = is.active(anet, -Inf, 20, e=6, rule='all')    # for (-Inf,H) &   (a, a)
  > f37 = is.active(anet, 0, Inf, e=6, rule='all')      # for (L,Inf) &    (a, a)
  > f38 = is.active(anet, 30, Inf, e=6, rule='all')     # for (H,Inf) &    (a, a)
  > f39 = is.active(anet, 0, 10, e=6, rule='all')       # for (L,a) &      (a, a)
  > f40 = is.active(anet, 10, 20, e=6, rule='all')      # for (a,H) &      (a, a)
  > f41 = is.active(anet, 30, 35, e=7, rule='all')      # for (a,H) &      (a, a)
  > f42 = is.active(anet, -5, 0, e=6, rule='all')       # for (L,L) &      (a, a)
  > f43 = is.active(anet, 0, 40, e=6, rule='all')       # for (L,H) &      (a, a)
  > f44 = is.active(anet, 30, 40, e=6, rule='all')      # for (H,H) &      (a, a)
  > 
  > f.tests = paste("f", seq(1,43), sep="")
  > f.results= sapply(f.tests, function(x){eval(parse(text=x))})
  > if(any(f.results)){
  +   bad.tests = paste("f", which(f.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper TRUE values in tests",
  +              bad.tests))
  + }
  > 
  > 
  > # interval queries that should be FALSE using default 'rule=any'
  > g1  = is.active(anet, 4, 5, e= 1, active.default=F)       # for any & NULL
  > g2  = is.active(anet, -Inf, Inf, e= 1, active.default=F)  # for any & NULL  
  > g3  = is.active(anet, 3, 5, e= 8)       # for 'never active' NULL spell
  > g4  = is.active(anet, -Inf, Inf, e= 8)  # for 'never active' NULL spell
  > g5  = is.active(anet, Inf, Inf, e=3)    # for (Inf, Inf) &  (-Inf, b)
  > g6  = is.active(anet, 30, Inf, e=3)     # for (H, Inf) &    (-Inf, b)
  > g7  = is.active(anet, 20, 30, e=3)      # for (b, H) &      (-Inf, b)
  > g8  = is.active(anet, 30, 40, e=3)      # for (H, H) &      (-Inf, b)
  > g9  = is.active(anet, -Inf, -Inf, e=4)  # for (-Inf,-Inf) & (a, Inf)
  > g10 = is.active(anet, -Inf, 0, e=4)     # for (-Inf,L) &    (a, Inf)
  > g11 = is.active(anet, 0, 10, e=4)       # for (L, a) &      (a, Inf)
  > g12 = is.active(anet, 0, 5, e=4)        # for (L, L) &      (a, Inf)
  > g13 = is.active(anet, -Inf, -Inf, e=5)  # for (-Inf,-Inf) & (a, b)
  > g14 = is.active(anet, Inf, Inf, e=5)    # for (Inf, Inf) &  (a, b)
  > g15 = is.active(anet, -Inf, 0, e=5)     # for (-Inf, L) &   (a, b)
  > g16 = is.active(anet, 30, Inf, e=5)     # for (H, Inf) &    (a, b)
  > g17 = is.active(anet, -5, 10, e=5)      # for (L,a) &       (a, b)
  > g18 = is.active(anet, 20, 30, e=5)      # for (b,H) &       (a, b)
  > g19 = is.active(anet, -5, 5, e=5)       # for (L,L) &       (a, b)
  > g20 = is.active(anet, 30, 40, e=5)      # for (H,H) &       (a, b)
  > g21 = is.active(anet, -Inf,-Inf, e=6)   # for (-Inf,-Inf) & (a, a)
  > g22 = is.active(anet, -Inf, 0, e=6)     # for (-Inf,L) &    (a, a)
  > g23 = is.active(anet, -Inf, 10, e=6)    # for (-Inf,a) &    (a, a)
  > g24 = is.active(anet, 30, Inf, e=6)     # for (H,Inf) &     (a, a)
  > g25 = is.active(anet, 0, 10, e=6)       # for (L,a) &       (a, a)
  > g26 = is.active(anet, -5, 0, e=6)       # for (L1,L2) &     (a, a)
  > g27 = is.active(anet, 30, 40, e=6)      # for (H1,H2) &     (a, a)
  > 
  > g.tests = paste("g", seq(1,27), sep="")
  > g.results= sapply(g.tests, function(x){eval(parse(text=x))})
  > if(any(g.results)){
  +   bad.tests = paste("g", which(g.results), sep="", collapse=" ")
  +   stop(paste("is.active is returning improper TRUE values in tests",
  +              bad.tests))
  + }
  > 
  > expect_equal(is.active(network.initialize(0),at=1),logical(0))
  Error in expect_equal(is.active(network.initialize(0), at = 1), logical(0)) : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/reconcile.activityTests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > # tests for the reconcile activity functions
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > 
  > # ---- reconcile.vertex.activity tests ------------
  > # test when called with wrong object
  > expect_error(reconcile.vertex.activity("net"), 'only be applied to networkDynamic objects')
  Error in expect_error(reconcile.vertex.activity("net"), "only be applied to networkDynamic objects") : 
    could not find function "expect_error"
  Execution halted
Running the tests in ‘tests/tea_tests.R’ failed.
Complete output:
  > #  Part of the statnet package, http://statnetproject.org
  > #
  > #  This software is distributed under the GPL-3 license.  It is free,
  > #  open source, and has the attribution requirements (GPL Section 7) in
  > #    http://statnetproject.org/attribution
  > #
  > #  Copyright 2013 the statnet development team
  > ######################################################################
  > 
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > # -------------- activate.vertex.attribute----------------------
  > 
  > # gives error if argument not a network?
  > nd <-list()
  > expect_error(activate.vertex.attribute(nd,"letters","a",onset=0,terminus=1),"requires that the first argument be a network")
  Error in expect_error(activate.vertex.attribute(nd, "letters", "a", onset = 0,  : 
    could not find function "expect_error"
  Execution halted
Running the tests in ‘tests/utils_tests.R’ failed.
Complete output:
  > # tests for utilities functions
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > # ------- test for adjust.activity -----
  > 
  > test<-network.initialize(3)
  > activate.vertices(test,onset=0,terminus=3,v=1:2)
  > add.edges.active(test,tail=1:2,head=2:3,onset=0,terminus=3)
  > add.edge(test,tail=3,head=1)
  > activate.vertex.attribute(test,'fruit','apple',v=1:2,onset=0,terminus=3)
  > activate.edge.attribute(test,'veggie','carrot',e=1:2,onset=0,terminus=3)
  > activate.network.attribute(test,'meat','pork',onset=0,terminus=3)
  > test%n%'net.obs.period'<-list(observations=list(c(0,1),c(1,2),c(2,3)),mode="discrete", time.increment=1,time.unit="step")
  > 
  > # test offset and return value
  > test2<-adjust.activity(test,offset=5)
  > 
  > expect_equal(test2$val[[1]]$active,matrix(c(5,8),ncol=2))
  Error in expect_equal(test2$val[[1]]$active, matrix(c(5, 8), ncol = 2)) : 
    could not find function "expect_equal"
  Execution halted
Running the tests in ‘tests/when_tests.R’ failed.
Complete output:
  > # tests for the when functions
  > require(testthat)
  Loading required package: testthat
  Warning message:
  In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
    there is no package called 'testthat'
  > require(networkDynamic)
  Loading required package: networkDynamic
  Loading required package: network
  network: Classes for Relational Data
  Version 1.16.0 created on 2019-11-30.
  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.
  
  
  networkDynamic: version 0.10.1, created on 2020-01-16
  Copyright (c) 2020, Carter T. Butts, University of California -- Irvine
                      Ayn Leslie-Cook, University of Washington
                      Pavel N. Krivitsky, University of Wollongong
                      Skye Bender-deMoll, University of Washington
                      with contributions from
                      Zack Almquist, University of California -- Irvine
                      David R. Hunter, Penn State University
                      Li Wang
                      Kirk Li, University of Washington
                      Steven M. Goodreau, University of Washington
                      Jeffrey Horner
                      Martina Morris, University of Washington
  Based on "statnet" project software (statnet.org).
  For license and citation information see statnet.org/attribution
  or type citation("networkDynamic").
  
  > 
  > #------ when.vertex.attrs.match tests ----- 
  > 
  > test1<-network.initialize(5)
  > test1<-activate.vertex.attribute(test1,'myValue',1:5,onset=1,terminus=2)
  > test1<-activate.vertex.attribute(test1,'myValue',10:15,onset=2,terminus=3)
  > test1<-activate.vertex.attribute(test1,'myValue',-5:0,onset=5,terminus=12)
  > 
  > # basic test
  > expect_equal(when.vertex.attrs.match(test1,attrname='myValue',value=3),c(Inf,Inf,1,Inf,Inf))
  Error in expect_equal(when.vertex.attrs.match(test1, attrname = "myValue",  : 
    could not find function "expect_equal"
  Execution halted