# Add graphs to graphs

test_that("Adding a balanced tree is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a balanced tree
  graph <-
    add_balanced_tree(
      graph = graph,
      k = 3,
      h = 3,
      type = "a",
      rel = "z")

  # Expect 40 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 40)

  # Expect 39 edges to have been created
  expect_equal(
    count_edges(graph = graph), 39)

  # Expect node ID values from 1 to 40
  expect_identical(
    get_node_ids(graph), 1:40)

  # Expect label values from 1 to 40
  expect_identical(
    graph$nodes_df$label,
    as.character(1:40))

  # Expect type values to all be `a`
  expect_in(graph$nodes_df$type, "a")

  # Expect rel values to all be `z`
  expect_in(graph$edges_df$rel, "z")

  # Expect an error if h <2 or k <2
  expect_snapshot(error = TRUE, {
    # k < 2
    add_balanced_tree(
      graph = graph,
      k = 1,
      h = 3,
      type = "a",
      rel = "z")
    # h < 2
    add_balanced_tree(
      graph = graph,
      k = 3,
      h = 1,
      type = "a",
      rel = "z")
  }
  )

  # Add another balanced tree to the graph
  graph <-
    add_balanced_tree(
      graph = graph,
      k = 2,
      h = 2,
      type = "b",
      rel = "y")

  # Expect that 47 nodes are now in the graph
  expect_equal(count_nodes(graph = graph), 47)

  # Expect 45 edges are now in the graph
  expect_equal(count_edges(graph = graph), 45)

  # Expect node ID values from 1 to 47
  expect_identical(
    get_node_ids(graph), 1:47)

  # Expect label values from 1 to 47
  expect_equal(
    graph$nodes_df$label,
    as.character(1:47))

  # Expect type values to be either `a` or `b`
  expect_in(graph$nodes_df$type, c("a", "b"))

  # Expect rel values to be either `y` or `z`
  expect_in(graph$edges_df$rel, c("y", "z"))
})

test_that("Adding a cycle is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a cycle
  graph <-
    add_cycle(
      graph = graph,
      n = 3,
      type = "a",
      rel = "z")

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 3 edges to have been created
  expect_equal(
    count_edges(graph = graph), 3)

  # Expect node ID values from 1 to 3
  expect_identical(
    get_node_ids(graph), 1:3)

  # Expect label values from 1 to 3
  expect_identical(
    graph$nodes_df$label,
    as.character(1:3))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if n is <3
  expect_error(
    add_cycle(
      graph = graph,
      n = 2,
      type = "a",
      rel = "z"))

  # Add another cycle to the graph
  graph <-
    add_cycle(
      graph = graph,
      n = 3,
      type = "b",
      rel = "y")

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph), 6)

  # Expect 6 edges are now in the graph
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect node ID values from 1 to 6
  expect_identical(
    get_node_ids(graph), 1:6)

  # Expect label values from 1 to 6
  expect_identical(
    graph$nodes_df$label,
    as.character(1:6))

  # Expect type values to be either `a` or `b`
  expect_in(graph$nodes_df$type, c("a", "b"))

  # Expect rel values to be either `y` or `z`
  expect_in(graph$edges_df$rel, c("y", "z"))

  # Create a graph with a cycle that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_cycle(
      n = 6,
      label = c("one", "two",
                "three", "four",
                "five", "six"),
      type = c("a", "a",
               "b", "b",
               "c", "c"),
      rel = c("cycle_a", "cycle_a",
              "cycle_b", "cycle_b",
              "cycle_c", "cycle_c"))

  # Get the graph's node data frame
  ndf <- get_node_df(graph_2)

  # Get the graph's edge data frame
  edf <- get_edge_df(graph_2)

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph_2), 6)

  # Expect 6 edges are now in the graph
  expect_equal(
    count_edges(graph = graph_2), 6)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:6)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two",
      "three", "four",
      "five", "six"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "b",
      "b", "c", "c"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("cycle_a", "cycle_a",
      "cycle_b", "cycle_b",
      "cycle_c", "cycle_c"))
})

test_that("Adding a path is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a path
  graph <-
    add_path(
      graph = graph,
      n = 3,
      type = "a",
      rel = "z")

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 2 edges to have been created
  expect_equal(
    count_edges(graph = graph), 2)

  # Expect node ID values from 1 to 3
  expect_identical(
    get_node_ids(graph), 1:3)

  # Expect label values from 1 to 3
  expect_identical(
    graph$nodes_df$label,
    as.character(1:3))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if n is <2
  expect_snapshot(error = TRUE,
    add_path(
      graph = graph,
      n = 1,
      type = "a",
      rel = "z"))

  # Add another path to the graph
  graph <-
    add_path(
      graph = graph,
      n = 3,
      type = "b",
      rel = "y")

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph), 6)

  # Expect 6 edges are now in the graph
  expect_equal(
    count_edges(graph = graph), 4)

  # Expect node ID values from 1 to 6
  expect_identical(
    get_node_ids(graph), 1:6)

  # Expect label values from 1 to 6
  expect_identical(
    graph$nodes_df$label,
    as.character(1:6))

  # Expect type values to be either `a` or `b`
  expect_setequal(
    graph$nodes_df$type,
    c("a", "b"))

  # Expect rel values to be either `y` or `z`
  expect_setequal(
    graph$edges_df$rel,
    c("y", "z"))

  # Create a graph with a path that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_path(
      n = 6,
      label = c("one", "two",
                "three", "four",
                "five", "six"),
      type = c("a", "a",
               "a", "b",
               "b", "b"),
      rel = c("path_a", "path_b",
              "path_c", "path_d",
              "path_e"))

  # Get the graph's node data frame
  ndf <- get_node_df(graph_2)

  # Get the graph's edge data frame
  edf <- get_edge_df(graph_2)

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph_2), 6)

  # Expect 5 edges are now in the graph
  expect_equal(
    count_edges(graph = graph_2), 5)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:6)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two",
      "three", "four",
      "five", "six"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "a",
      "b", "b", "b"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("path_a", "path_b",
      "path_c", "path_d",
      "path_e"))
})

test_that("Adding a prism is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a prism
  graph <-
    add_prism(
      graph = graph,
      n = 3,
      type = "a",
      rel = "z")

  # Expect 6 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 6)

  # Expect 9 edges to have been created
  expect_equal(
    count_edges(graph = graph), 9)

  # Expect node ID values from 1 to 6
  expect_identical(
    get_node_ids(graph), 1:6)

  # Expect label values from 1 to 6
  expect_identical(
    graph$nodes_df$label,
    as.character(1:6))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if n is <3
  expect_error(
    add_prism(
      graph = graph,
      n = 2,
      type = "a",
      rel = "z"))

  # Add another prism to the graph
  graph <-
    add_prism(
      graph = graph,
      n = 3,
      type = "b",
      rel = "y")

  # Expect that 12 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph), 12)

  # Expect 18 edges are now in the graph
  expect_equal(
    count_edges(graph = graph), 18)

  # Expect label values from 1 to 12
  expect_identical(
    graph$nodes_df$label,
    as.character(1:12))

  # Expect type values to be either `a` or `b`
  expect_identical(
    unique(graph$nodes_df$type),
    c("a", "b"))

  # Expect rel values to be either `a` or `b`
  expect_identical(
    unique(graph$edges_df$rel),
    c("z", "y"))

  # Create a graph with a prism that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_prism(
      n = 3,
      label = c("one", "two",
                "three", "four",
                "five", "six"),
      type = c("a", "a",
               "a", "b",
               "b", "b"),
      rel = c("prism_a", "prism_a",
              "prism_a", "prism_b",
              "prism_b", "prism_b",
              "prism_c", "prism_c",
              "prism_c"))

  # Get the graph's node data frame
  ndf <- get_node_df(graph_2)

  # Get the graph's edge data frame
  edf <- get_edge_df(graph_2)

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph_2), 6)

  # Expect 9 edges are now in the graph
  expect_equal(
    count_edges(graph = graph_2), 9)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:6)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two",
      "three", "four",
      "five", "six"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "a",
      "b", "b", "b"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("prism_a", "prism_a",
      "prism_a", "prism_b",
      "prism_b", "prism_b",
      "prism_c", "prism_c",
      "prism_c"))
})

test_that("Adding a star is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a star
  graph <-
    add_star(
      graph = graph,
      n = 4,
      type = "a",
      rel = "z")

  # Expect 4 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 4)

  # Expect 3 edges to have been created
  expect_equal(
    count_edges(graph = graph), 3)

  # Expect node ID values from 1 to 4
  expect_identical(
    get_node_ids(graph), 1:4)

  # Expect label values from 1 to 4
  expect_identical(
    graph$nodes_df$label,
    as.character(1:4))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if n is <4
  expect_error(
    add_star(
      graph = graph,
      n = 3,
      type = "a",
      rel = "z"))

  # Add another star to the graph
  graph <-
    add_star(
      graph = graph,
      n = 4,
      type = "b",
      rel = "y")

  # Expect that 8 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph), 8)

  # Expect 6 edges are now in the graph
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect node ID values from 1 to 8
  expect_identical(
    get_node_ids(graph), 1:8)

  # Expect label values from 1 to 8
  expect_identical(
    graph$nodes_df$label,
    as.character(1:8))

  # Expect type values to be either `a` or `b`
  expect_identical(
    unique(graph$nodes_df$type),
    c("a", "b"))

  # Expect rel values to be either `z` or `y`
  expect_identical(
    unique(graph$edges_df$rel),
    c("z", "y"))

  # Create a graph with a star that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_star(
      n = 6,
      label = c("one", "two",
                "three", "four",
                "five", "six"),
      type = c("a", "a",
               "b", "b",
               "c", "c"),
      rel = c("star_a", "star_b",
              "star_c", "star_d",
              "star_e"))

  # Get the graph's node data frame
  ndf <- graph_2 %>% get_node_df()

  # Get the graph's edge data frame
  edf <- graph_2 %>% get_edge_df()

  # Expect that 6 nodes are now in the graph
  expect_equal(
    count_nodes(graph = graph_2), 6)

  # Expect 5 edges are now in the graph
  expect_equal(
    count_edges(graph = graph_2), 5)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:6)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two",
      "three", "four",
      "five", "six"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "b",
      "b", "c", "c"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("star_a", "star_b",
      "star_c", "star_d",
      "star_e"))
})

test_that("Adding a 2D grid is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a 2D grid
  graph <-
    add_grid_2d(
      graph = graph,
      x = 3,
      y = 3,
      type = "a",
      rel = "z")

  # Expect 9 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 9)

  # Expect 12 edges to have been created
  expect_equal(
    count_edges(graph = graph), 12)

  # Expect node ID values from 1 to 9
  expect_identical(
    get_node_ids(graph = graph), 1:9)

  # Expect label values from 1 to 9
  expect_identical(
    graph$nodes_df$label,
    as.character(1:9))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if x is <2
  expect_error(
    add_grid_2d(
      graph = graph,
      x = 1,
      y = 3,
      type = "a",
      rel = "z"))

  # Expect an error if y is <2
  expect_error(
    add_grid_2d(
      graph = graph,
      x = 3,
      y = 1,
      type = "a",
      rel = "z"))

  # Add another 2D grid to the graph
  graph <-
    add_grid_2d(
      graph = graph,
      x = 2,
      y = 2,
      type = "b",
      rel = "y")

  # Expect that 13 nodes are now in the graph
  expect_equal(
    count_nodes(graph), 13)

  # Expect 16 edges are now in the graph
  expect_equal(
    count_edges(graph), 16)

  # Expect label values from 1 to 13
  expect_identical(
    graph$nodes_df$label,
    as.character(1:13))

  # Expect type values to be either `a` or `b`
  expect_identical(
    unique(graph$nodes_df$type),
    c("a", "b"))

  # Expect rel values to be either `z` or `y`
  expect_identical(
    unique(graph$edges_df$rel),
    c("z", "y"))

  # Create a graph with a 2D grid that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_grid_2d(
      x = 2,
      y = 2,
      label = c(
        "one", "two",
        "three", "four"),
      type = c(
        "a", "a",
        "b", "b"),
      rel = c(
        "grid_a", "grid_a",
        "grid_b", "grid_b"))

  # Get the graph's node data frame
  ndf <- get_node_df(graph_2)

  # Get the graph's edge data frame
  edf <- get_edge_df(graph_2)

  # Expect that 4 nodes are now in the graph
  expect_equal(
    count_nodes(graph_2), 4)

  # Expect 4 edges are now in the graph
  expect_equal(
    count_edges(graph_2), 4)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:4)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two", "three", "four"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "b", "b"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("grid_a", "grid_a", "grid_b", "grid_b"))
})

test_that("Adding a 3D grid is possible", {

  # Create an empty graph
  graph <- create_graph()

  # Add a 3D grid
  graph <-
    add_grid_3d(
      graph = graph,
      x = 2,
      y = 2,
      z = 2,
      type = "a",
      rel = "z")

  # Expect 8 nodes to have been created
  expect_equal(
    count_nodes(graph), 8)

  # Expect 12 edges to have been created
  expect_equal(
    count_edges(graph), 12)

  # Expect node ID values from 1 to 8
  expect_identical(
    get_node_ids(graph), 1:8)

  # Expect label values from 1 to 8
  expect_identical(
    graph$nodes_df$label,
    as.character(1:8))

  # Expect type values to all be `a`
  expect_equal(
    unique(graph$nodes_df$type), "a")

  # Expect rel values to all be `z`
  expect_equal(
    unique(graph$edges_df$rel), "z")

  # Expect an error if x is <2
  expect_error(
    add_grid_3d(
      graph = graph,
      x = 1,
      y = 3,
      z = 3,
      type = "a",
      rel = "z"))

  # Expect an error if y is <2
  expect_error(
    add_grid_3d(
      graph = graph,
      x = 3,
      y = 1,
      z = 3,
      type = "a",
      rel = "z"))

  # Expect an error if z is <2
  expect_error(
    add_grid_3d(
      graph = graph,
      x = 3,
      y = 3,
      z = 1,
      type = "a",
      rel = "z"))

  # Add another 3D grid to the graph
  graph <-
    add_grid_3d(
      graph = graph,
      x = 2,
      y = 2,
      z = 2,
      type = "b",
      rel = "y")

  # Expect that 13 nodes are now in the graph
  expect_equal(
    count_nodes(graph), 16)

  # Expect 24 edges are now in the graph
  expect_equal(
    count_edges(graph), 24)

  # Expect label values from 1 to 16
  expect_identical(
    graph$nodes_df$label,
    as.character(1:16))

  # Expect type values to be either `a` or `b`
  expect_identical(
    unique(graph$nodes_df$type),
    c("a", "b"))

  # Expect rel values to be either `z` or `y`
  expect_identical(
    unique(graph$edges_df$rel),
    c("z", "y"))

  # Create a graph with a 2D grid that
  # has different types of node and edge
  # attributes included
  graph_2 <-
    create_graph() %>%
    add_grid_3d(
      x = 2,
      y = 2,
      z = 2,
      label = c(
        "one", "two",
        "three", "four",
        "five", "six",
        "seven", "eight"),
      type = c(
        "a", "a", "a", "a",
        "b", "b", "b", "b"),
      rel = c(
        "grid_a", "grid_a", "grid_a",
        "grid_a", "grid_a", "grid_a",
        "grid_b", "grid_b", "grid_b",
        "grid_b", "grid_b", "grid_b"))

  # Get the graph's node data frame
  ndf <- get_node_df(graph_2)

  # Get the graph's edge data frame
  edf <- get_edge_df(graph_2)

  # Expect that 8 nodes are now in the graph
  expect_equal(
    count_nodes(graph_2), 8)

  # Expect 12 edges are now in the graph
  expect_equal(
    count_edges(graph_2), 12)

  # Expect node ID values from 1 to 6
  expect_identical(
    ndf$id, 1:8)

  # Expect specific node `label` values
  expect_identical(
    ndf$label,
    c("one", "two", "three", "four",
      "five", "six", "seven", "eight"))

  # Expect specific node `type` values
  expect_identical(
    ndf$type,
    c("a", "a", "a", "a",
      "b", "b", "b", "b"))

  # Expect specific edge `rel` values
  expect_identical(
    edf$rel,
    c("grid_a", "grid_a", "grid_a",
      "grid_a", "grid_a", "grid_a",
      "grid_b", "grid_b", "grid_b",
      "grid_b", "grid_b", "grid_b"))
})

test_that("Adding a full graph is possible", {

  # Create a graph and add a full graph
  # with 3 nodes to it; keep loops
  graph <-
    create_graph() %>%
    add_full_graph(
      n = 3,
      keep_loops = TRUE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 9 edges to have been created
  expect_equal(
    count_edges(graph = graph), 9)

  # Expect that there are 3 loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    3)

  # Expect node ID values from 1 to 3
  expect_identical(
    get_node_ids(graph), 1:3)

  # Expect type values to be character NA values
  expect_equal(
    unique(graph$nodes_df$type),
    NA_character_)

  # Create a graph and add a full graph
  # with 3 nodes to it; discard loops
  graph <-
    create_graph() %>%
    add_full_graph(
      n = 3,
      keep_loops = FALSE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect that there are no loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    0)

  # Create a graph, add a full graph
  # (with no loops), set values for the
  # node `label`, node `type`, and edge `rel`
  graph <-
    create_graph() %>%
    add_full_graph(
      n = 3,
      type = "connected",
      label = c("1st", "2nd", "3rd"),
      rel = "connected_to")

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect that there are no loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    0)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(get_node_df(graph)[, 2]),
    "connected")

  # Expect that the `label` values
  # assigned to the nodes are in the
  # graph's internal node data frame
  expect_equal(
    graph$nodes_df$label,
    c("1st", "2nd", "3rd"))

  # Expect that the `label` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "connected_to")

  # Create a fully-connected and directed
  # graph with 3 nodes, and, where a matrix
  # provides edge weights; first, create a
  # matrix to be used for edge weights
  # matrix (with row names to be used as
  # node labels)
  suppressWarnings(RNGversion("3.5.0"))
  set.seed(23)

  edge_wt_matrix_rownames <-
    rnorm(n = 100, mean = 5, sd = 2) %>%
    sample(size = 9, replace = FALSE) %>%
    round(digits = 2) %>%
    matrix(
      ncol = 3,
      nrow = 3,
      dimnames = list(c("a", "b", "c")))

  # Create a fully-connected graph without
  # loops and use the matrix to provide
  # values for the edge `weight` attribute
  graph <-
    create_graph() %>%
    add_full_graph(
      n = 3,
      type = "weighted",
      label = TRUE,
      rel = "related_to",
      edge_wt_matrix = edge_wt_matrix_rownames,
      keep_loops = FALSE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect that there are no loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    0)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(get_node_df(graph)[, 2]),
    "weighted")

  # Expect that the `label` values
  # assigned to the nodes are the same
  # as the matrix rownames
  expect_equal(
    graph$nodes_df$label,
    rownames(edge_wt_matrix_rownames))

  # Expect that the `rel` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "related_to")

  # Expect certain values for the
  # edge weight attribute
  expect_equal(
    graph$edges_df$weight,
    c(3.3, 5.02, 4.13,
      6.49, 6.03, 5.55))

  # Create a fully-connected but undirected
  # graph without loops and use the matrix
  # to provide values for the edge `weight`
  # attribute; in this case, the lower
  # triangle of the matrix will be used
  graph <-
    create_graph(directed = FALSE) %>%
    add_full_graph(
      n = 3,
      type = "weighted",
      label = TRUE,
      rel = "related_to",
      edge_wt_matrix = edge_wt_matrix_rownames,
      keep_loops = FALSE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 3 edges to have been created
  expect_equal(
    count_edges(graph = graph), 3)

  # Expect that there are no loops in the graph
  expect_length(
    which(graph$edges_df$from ==  graph$edges_df$to),
    0)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(graph$nodes_df$type),
    "weighted")

  # Expect that the `label` values
  # assigned to the nodes are the same
  # as the matrix rownames
  expect_equal(
    graph$nodes_df$label,
    rownames(edge_wt_matrix_rownames))

  # Expect that the `rel` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "related_to")

  # Expect certain values for the
  # edge weight attribute
  expect_equal(
    graph$edges_df$weight,
    c(3.3, 5.02, 6.49))

  # Create a fully-connected graph with
  # loop preserved and use the matrix to
  # provide values for the edge `weight`
  # attribute
  graph <-
    create_graph() %>%
    add_full_graph(
      n = 3,
      type = "weighted",
      label = TRUE,
      rel = "related_to",
      edge_wt_matrix = edge_wt_matrix_rownames,
      keep_loops = TRUE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 9 edges to have been created
  expect_equal(
    count_edges(graph = graph), 9)

  # Expect that there are 3 loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    3)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(graph$nodes_df$type),
    "weighted")

  # Expect that the `label` values
  # assigned to the nodes are the same
  # as the matrix rownames
  expect_equal(
    graph$nodes_df$label,
    rownames(edge_wt_matrix_rownames))

  # Expect that the `rel` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "related_to")

  # Expect certain values for the
  # edge weight attribute
  expect_equal(
    graph$edges_df$weight,
    c(8.66, 3.3, 5.02, 4.13, 6.83,
      6.49, 6.03, 5.55, 3.8))

  # Create a fully-connected and undirected
  # graph with loops preserved; use the
  # matrix to provide values for the edge
  # `weight` attribute
  graph <-
    create_graph(directed = FALSE) %>%
    add_full_graph(
      n = 3,
      type = "weighted",
      label = TRUE,
      rel = "related_to",
      edge_wt_matrix = edge_wt_matrix_rownames,
      keep_loops = TRUE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect that there are 3 loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    3)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(graph$nodes_df$type),
    "weighted")

  # Expect that the `label` values
  # assigned to the nodes are the same
  # as the matrix rownames
  expect_equal(
    graph$nodes_df$label,
    rownames(edge_wt_matrix_rownames))

  # Expect that the `rel` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "related_to")

  # Expect certain values for the
  # edge weight attribute
  expect_equal(
    graph$edges_df$weight,
    c(8.66, 3.3, 5.02, 6.83, 6.49, 3.8))

  # Create a fully-connected and undirected
  # graph with loops preserved; use the
  # matrix to provide values for the edge
  # `weight` attribute, however, do not add
  # labels to this graph
  graph <-
    create_graph(directed = FALSE) %>%
    add_full_graph(
      n = 3,
      type = "weighted",
      label = NULL,
      rel = "related_to",
      edge_wt_matrix = edge_wt_matrix_rownames,
      keep_loops = TRUE)

  # Expect 3 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 3)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 6)

  # Expect that there are 3 loops in the graph
  expect_length(
    which(graph$edges_df$from == graph$edges_df$to),
    3)

  # Expect that the `type` node attr
  # has the value `connected` for all
  # nodes created
  expect_equal(
    unique(graph$nodes_df$type),
    "weighted")

  # Expect that the `label` values are
  # character NA values
  expect_equal(
    graph$nodes_df$label,
    rep(NA_character_, 3))

  # Expect that the `rel` edge attr
  # has the value `connected_to` for
  # all edges created
  expect_equal(
    unique(graph$edges_df$rel),
    "related_to")

  # Expect certain values for the
  # edge weight attribute
  expect_equal(
    graph$edges_df$weight,
    c(8.66, 3.3, 5.02, 6.83, 6.49, 3.8))

  # Create a graph with a cycle then
  # and add a full graph
  # with 3 nodes to it; discard loops
  graph <-
    create_graph() %>%
    add_cycle(
      n = 5,
      type = "cycle") %>%
    add_full_graph(
      n = 8,
      keep_loops = FALSE)

  # Expect 13 nodes to have been created
  expect_equal(
    count_nodes(graph = graph), 13)

  # Expect 6 edges to have been created
  expect_equal(
    count_edges(graph = graph), 61)
})

test_that("Adding a G(n, m) Erdos-Renyi graph is possible", {

  # Create an undirected GNM
  # graph with 100 nodes and
  # 120 edges
  gnm_graph <-
    create_graph(
      directed = FALSE) %>%
    add_gnm_graph(
      n = 100,
      m = 120)

  # Expect 100 nodes in the graph
  expect_equal(
    gnm_graph %>%
      count_nodes(),
    100)

  # Expect 120 edges in the graph
  expect_equal(
    gnm_graph %>%
      count_edges(),
    120)

  # Create 2 graphs made with the same
  # `n`, `m`, and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_gnm_graph(
      n = 100,
      m = 120,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_gnm_graph(
      n = 100,
      m = 120,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add a GNM graph with 100 nodes
  # and 120 edges
  gnm_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_gnm_graph(
      n = 100,
      m = 120) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "GNM") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    gnm_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 200 nodes have a
  # node ID sequence from 1 to 200
  expect_identical(
    gnm_graph_added$nodes_df$id,
    1:200)

  # Expect an error if the value for
  # `n` is too small (< 1)
  expect_error(
    create_graph() %>%
    add_gnm_graph(n = 0, m = 5))
})

test_that("Adding a G(n, p) Erdos-Renyi graph is possible", {

  # Create an undirected GNM
  # graph with 100 nodes and
  # a probability of 0.05 for
  # creating edges
  gnp_graph <-
    create_graph(
      directed = FALSE) %>%
    add_gnp_graph(
      n = 100,
      p = 0.05,
      set_seed = 23)

  # Expect 100 nodes in the graph
  expect_equal(
    gnp_graph %>%
      count_nodes(),
    100)

  # Expect 233 edges in the graph
  expect_equal(
    gnp_graph %>%
      count_edges(),
    233)

  # Create 2 graphs made with the same
  # `n`, `p`, and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_gnp_graph(
      n = 100,
      p = 0.06,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_gnp_graph(
      n = 100,
      p = 0.06,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add a GNP graph with 100 nodes
  gnp_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_gnp_graph(
      n = 100,
      p = 0.06) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "GNP") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    gnp_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 200 nodes have a
  # node ID sequence from 1 to 200
  expect_identical(
    gnp_graph_added$nodes_df$id,
    1:200)

  # Expect an error if the value for
  # `n` is too small (< 1)
  expect_error(
    create_graph() %>%
      add_gnp_graph(n = 0, p = 0.05))
})

test_that("Adding a growing graph is possible", {

  # Create a random, growing
  # citation graph with 100
  # nodes, adding an edge after
  # each node addition
  growing_graph <-
    create_graph() %>%
    add_growing_graph(
      n = 100,
      m = 1,
      citation = TRUE,
      set_seed = 23)

  # Expect 100 nodes in the graph
  expect_equal(
    growing_graph %>%
      count_nodes(),
    100)

  # Expect 99 edges in the graph
  expect_equal(
    growing_graph %>%
      count_edges(),
    99)

  # Create 2 graphs made with the same
  # `n`, `m`, and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_growing_graph(
      n = 100,
      m = 1,
      citation = TRUE,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_growing_graph(
      n = 100,
      m = 1,
      citation = TRUE,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add a growing graph with 100 nodes
  growing_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_growing_graph(
      n = 100,
      m = 1) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "growing") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    growing_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 200 nodes have a
  # node ID sequence from 1 to 200
  expect_identical(
    growing_graph_added$nodes_df$id,
    1:200)

  # Expect an error if the value for
  # `n` is too small (< 1)
  expect_error(
    create_graph() %>%
      add_growing_graph(n = 0, m = 1))
})

test_that("Adding an islands graph is possible", {

  # Create an undirected islands
  # graph with standard parameters
  islands_graph <-
    create_graph(
      directed = FALSE) %>%
    add_islands_graph(
      n_islands = 4,
      island_size = 10,
      p = 0.5,
      edges_between = 1,
      set_seed = 23)

  # Expect 40 nodes in the graph
  expect_equal(
    islands_graph %>%
      count_nodes(),
    40)

  # Expect more than 90 edges in the graph
  # with igraph < 2.0.0 there are 98, igraph 2.0.0 107
  expect_gt(
    count_edges(islands_graph),
    90)

  # Create 2 graphs made with the same
  # parameters and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_islands_graph(
      n_islands = 5,
      island_size = 10,
      p = 0.5,
      edges_between = 1,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_islands_graph(
      n_islands = 5,
      island_size = 10,
      p = 0.5,
      edges_between = 1,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add an islands graph with 100 nodes
  islands_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_islands_graph(
      n_islands = 10,
      island_size = 10,
      p = 0.5,
      edges_between = 1) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "islands") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    islands_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 200 nodes have a
  # node ID sequence from 1 to 200
  expect_identical(
    islands_graph_added$nodes_df$id,
    1:200)
})

test_that("Adding a preferential attachment graph is possible", {

  # Create an undirected PA
  # graph with 100 nodes, creating
  # an edge for every node created
  pa_graph <-
    create_graph(
      directed = FALSE) %>%
    add_pa_graph(
      n = 100,
      m = 1)

  # Expect 100 nodes in the graph
  expect_equal(
    pa_graph %>%
      count_nodes(),
    100)

  # Expect 99 edges in the graph
  expect_equal(
    pa_graph %>%
      count_edges(),
    99)

  # Create 2 graphs made with the same
  # `n`, `m`, and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_pa_graph(
      n = 200,
      m = 1,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_pa_graph(
      n = 200,
      p = 1,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add a PA graph with 100 nodes
  pa_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_pa_graph(
      n = 100,
      m = 1) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "PA") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    pa_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 200 nodes have a
  # node ID sequence from 1 to 200
  expect_identical(
    pa_graph_added$nodes_df$id,
    1:200)


  expect_snapshot(error = TRUE, {
    # Expect an error if the value for
    # `n` is too small (< 1)
    create_graph() %>%
      add_pa_graph(n = 0, m = 1)

    # Expect an error if the value for
    # `algo` is not a valid value
    create_graph() %>%
      add_pa_graph(n = 0, m = 1, algo = "plumtree")
    })

})

test_that("Adding a small world graph is possible", {

  # Create an undirected small world
  # graph with standard parameters
  smallworld_graph <-
    create_graph(
      directed = FALSE) %>%
    add_smallworld_graph(
      dimension = 1,
      size = 50,
      neighborhood = 1,
      p = 0.05,
      set_seed = 23)

  # Expect 50 nodes in the graph
  expect_equal(
    smallworld_graph %>%
      count_nodes(),
    50)

  # Expect 50 edges in the graph
  expect_equal(
    smallworld_graph %>%
      count_edges(),
    50)

  # Create 2 graphs made with the same
  # parameters and `set_seed` values
  graph_1 <-
    create_graph() %>%
    add_smallworld_graph(
      dimension = 1,
      size = 50,
      neighborhood = 1,
      p = 0.05,
      set_seed = 23)

  graph_2 <-
    create_graph() %>%
    add_smallworld_graph(
      dimension = 1,
      size = 50,
      neighborhood = 1,
      p = 0.05,
      set_seed = 23)

  # Expect that these graphs will
  # have the same node and edge definitions
  expect_identical(
    graph_1$nodes_df,
    graph_2$nodes_df)

  expect_identical(
    graph_1$edges_df,
    graph_2$edges_df)

  # Create a directed graph, add
  # a cycle of 100 nodes, and then
  # add a small world graph
  smallworld_graph_added <-
    create_graph() %>%
    add_cycle(
      n = 100,
      type = "cycle") %>%
    add_smallworld_graph(
      dimension = 1,
      size = 50,
      neighborhood = 1,
      p = 0.05) %>%
    select_last_nodes_created() %>%
    set_node_attrs_ws(
      node_attr = type,
      value = "smallworld") %>%
    clear_selection()

  # Expect that the first 100 nodes
  # belong to the `cycle` type
  expect_equal(
    smallworld_graph_added$nodes_df$type[1:100] %>%
      unique(),
    "cycle")

  # Expect that the 150 nodes have a
  # node ID sequence from 1 to 150
  expect_identical(
    smallworld_graph_added$nodes_df$id,
    1:150)
})
