Running ‘testthat.R’ [17s/20s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(DiagrammeR)
  > 
  > test_check("DiagrammeR")
  ── 1. Error: forward edges can be added given a selection of edges (@test-add_fo
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_edges() %>% add_forward_edges_ws("b") %>% add_forward_edges_ws("c") %>% 
         clear_selection() at testthat/test-add_forward_reverse_edges.R:20
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 2. Error: reverse edges can be added given a selection of edges (@test-add_fo
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_edges() %>% add_reverse_edges_ws("b") %>% add_reverse_edges_ws("c") %>% 
         clear_selection() at testthat/test-add_forward_reverse_edges.R:65
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 3. Error: Adding a balanced tree is possible (@test-add_graphs.R#26)  ───────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:40) at testthat/test-add_graphs.R:26
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 4. Error: Adding a cycle is possible (@test-add_graphs.R#119)  ──────────────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:3) at testthat/test-add_graphs.R:119
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 5. Error: Adding a path is possible (@test-add_graphs.R#264)  ───────────────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:3) at testthat/test-add_graphs.R:264
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 6. Error: Adding a prism is possible (@test-add_graphs.R#409)  ──────────────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:6) at testthat/test-add_graphs.R:409
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 7. Error: Adding a star is possible (@test-add_graphs.R#554)  ───────────────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:4) at testthat/test-add_graphs.R:554
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 8. Error: Adding a full graph is possible (@test-add_graphs.R#703)  ─────────
  `UQ()` can only be used within a quasiquoted argument
  1: expect_identical(get_node_ids(graph), 1:3) at testthat/test-add_graphs.R:703
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 9. Error: adding a node to a graph is possible (@test-add_node_edge.R#72)  ──
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(node_type(graph_3, node = 3), "fresh") at testthat/test-add_node_edge.R:72
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: node_type(graph_3, node = 3)
  5: node_present(graph = graph, node = node)
  6: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  7: node %in% get_node_ids(graph)
  8: get_node_ids(graph)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 10. Error: adding an edge to a graph is possible (@test-add_node_edge.R#313) 
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(all(c("3->4", "4->1") %in% get_edges(graph_2))) at testthat/test-add_node_edge.R:313
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: c("3->4", "4->1") %in% get_edges(graph_2)
  5: get_edges(graph_2)
  6: rlang::UQ(conditions) %>% paste()
  7: eval(lhs, parent, parent)
  8: eval(lhs, parent, parent)
  9: rlang::UQ(conditions)
  10: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 11. Error: adding several nodes to a graph at once is possible (@test-add_nod
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_node_ids(graph), c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) at testthat/test-add_node_edge.R:335
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 12. Error: adding several nodes to a graph at once (with extra attrs) is poss
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_node_ids(graph), c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) at testthat/test-add_node_edge.R:399
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 13. Error: adding several nodes from a selected node is possible (@test-add_n
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes(graph = graph, nodes = 5) at testthat/test-add_node_edge.R:438
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 14. Error: adding several nodes to a selected node is possible (@test-add_nod
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes(graph = graph, nodes = 5) at testthat/test-add_node_edge.R:527
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 15. Error: adding several edges with a string is possible (@test-add_node_edg
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_node_ids(graph), seq(1, 10)) at testthat/test-add_node_edge.R:627
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 16. Error: adding node clones is possible (@test-add_node_edge.R#727)  ──────
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% add_n_node_clones(n = 3, node = 1, label = c("x", "y", "z")) at testthat/test-add_node_edge.R:727
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: add_n_node_clones(., n = 3, node = 1, label = c("x", "y", "z"))
  10: graph %>% select_last_nodes_created() %>% get_selection()
  ...
  14: `_fseq`(`_lhs`)
  15: freduce(value, `_function_list`)
  16: function_list[[i]](value)
  17: select_last_nodes_created(.)
  18: select_nodes(graph = graph, nodes = node_id_values)
  19: rlang::UQ(conditions) %>% paste()
  20: eval(lhs, parent, parent)
  21: eval(lhs, parent, parent)
  22: rlang::UQ(conditions)
  23: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 17. Error: adding edge clones is possible (@test-add_node_edge.R#798)  ──────
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_path(n = 2, rel = "a") %>% select_last_edges_created() %>% 
         set_edge_attrs(edge_attr = color, values = "steelblue") %>% clear_selection() %>% 
         add_node() at testthat/test-add_node_edge.R:798
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = color, values = "steelblue")
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 18. Error: adding nodes from a table to a graph is possible (@test-add_nodes_
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_nodes_from_table(node_table) at testthat/test-add_nodes_edges_from_table.R:190
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: add_nodes_from_table(., node_table)
  10: rlang::UQ(label_col) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(label_col)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 19. Error: adding edges from a table to a graph is possible (@test-add_nodes_
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_nodes_from_table(node_table) at testthat/test-add_nodes_edges_from_table.R:661
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: add_nodes_from_table(., node_table)
  10: rlang::UQ(label_col) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(label_col)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 20. Error: Caching node attributes is possible (@test-cache_attrs.R#8)  ─────
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% set_node_attrs(node_attr = "value", values = rnorm(node_count(.), 
         5, 2)) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") at testthat/test-cache_attrs.R:8
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = "value", values = rnorm(node_count(.), 5, 2))
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 21. Error: Caching edge attributes is possible (@test-cache_attrs.R#95)  ────
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") %>% 
         set_edge_attrs(edge_attr = "value", values = rnorm(edge_count(.), 5, 2)) at testthat/test-cache_attrs.R:95
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = "value", values = rnorm(edge_count(.), 5, 2))
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 22. Error: Caching node attrs (w/ selection) is possible (@test-cache_attrs.R
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% set_node_attrs(node_attr = "value", values = rnorm(node_count(.), 
         5, 2)) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") at testthat/test-cache_attrs.R:183
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = "value", values = rnorm(node_count(.), 5, 2))
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 23. Error: Caching edge attrs (w/ selection) is possible (@test-cache_attrs.R
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") %>% 
         set_edge_attrs(edge_attr = "value", values = rnorm(edge_count(.), 5, 2)) at testthat/test-cache_attrs.R:271
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = "value", values = rnorm(edge_count(.), 5, 2))
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 24. Error: Caching node attrs (w/ selection) is possible (@test-cache_attrs.R
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% set_node_attrs(node_attr = "value", values = rnorm(node_count(.), 
         5, 2)) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") at testthat/test-cache_attrs.R:393
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = "value", values = rnorm(node_count(.), 5, 2))
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 25. Error: Caching edge attrs (w/ selection) is possible (@test-cache_attrs.R
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") %>% 
         set_edge_attrs(edge_attr = "value", values = rnorm(edge_count(.), 5, 2)) at testthat/test-cache_attrs.R:465
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = "value", values = rnorm(edge_count(.), 5, 2))
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 26. Error: Getting a cache is possible (@test-cache_attrs.R#550)  ───────────
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 10) %>% set_node_attrs(node_attr = "value", values = rnorm(node_count(.), 
         5, 2)) %>% add_edges_w_string(edges = "1->2 1->3 2->4 2->5 3->6 3->7 4->8 4->9 5->10") at testthat/test-cache_attrs.R:550
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = "value", values = rnorm(node_count(.), 5, 2))
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 27. Error: Adding color based on node attributes is possible (@test-colorize_
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% colorize_node_attrs(node_attr_from = walktrap_group, node_attr_to = fillcolor) at testthat/test-colorize_nodes_edges.R:23
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: colorize_node_attrs(., node_attr_from = walktrap_group, node_attr_to = fillcolor)
  10: rlang::UQ(node_attr_from) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr_from)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 28. Error: Adding color based on edge attributes is possible (@test-colorize_
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 10, m = 10, set_seed = 1) %>% set_edge_attrs(edge_attr = weight, 
         values = rnorm(edge_count(.), 5, 2)) %>% set_edge_attrs(edge_attr = "rel", values = c("A", 
         "A", "B", "B", "D", "A", "B", "C", "D", "A")) at testthat/test-colorize_nodes_edges.R:176
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = weight, values = rnorm(edge_count(.), 5, 2))
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 29. Error: Copying node attributes is possible (@test-copy_drop_mutate_recode
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% set_node_attrs(node_attr = value, 
         values = 1) at testthat/test-copy_drop_mutate_recode_attrs.R:6
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_node_attrs(., node_attr = value, values = 1)
  10: rlang::UQ(node_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 30. Error: Copying edge attributes is possible (@test-copy_drop_mutate_recode
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% add_edges_w_string(edges = "1->3 2->4 1->4 3->2") %>% 
         set_edge_attrs(edge_attr = value, values = 1) at testthat/test-copy_drop_mutate_recode_attrs.R:66
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = value, values = 1)
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 31. Error: Dropping node attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% set_node_attrs(node_attr = value, 
         values = 1) at testthat/test-copy_drop_mutate_recode_attrs.R:127
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_node_attrs(., node_attr = value, values = 1)
  10: rlang::UQ(node_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 32. Error: Dropping edge attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% add_edges_w_string(edges = "1->3 2->4 1->4 3->2") %>% 
         set_edge_attrs(edge_attr = value, values = 1) at testthat/test-copy_drop_mutate_recode_attrs.R:173
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = value, values = 1)
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 33. Error: Renaming node attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 5, m = 10, set_seed = 3) %>% set_node_attrs(node_attr = shape, 
         values = "circle") at testthat/test-copy_drop_mutate_recode_attrs.R:216
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_node_attrs(., node_attr = shape, values = "circle")
  10: rlang::UQ(node_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 34. Error: Renaming edge attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 5, m = 10, set_seed = 3) %>% set_edge_attrs(edge_attr = penwidth, 
         values = 5) %>% set_edge_attrs(edge_attr = arrowhead, values = "dot") at testthat/test-copy_drop_mutate_recode_attrs.R:296
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = penwidth, values = 5)
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 35. Error: Mutating node attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% set_node_attrs(node_attr = value, 
         values = 1) %>% set_node_attrs(node_attr = shape, values = "square") at testthat/test-copy_drop_mutate_recode_attrs.R:385
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = value, values = 1)
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 36. Error: Mutating edge attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% add_edges_w_string(edges = "1->3 2->4 1->4 3->2") %>% 
         set_edge_attrs(edge_attr = value, values = 1) %>% set_edge_attrs(edge_attr = color, 
         values = "red") at testthat/test-copy_drop_mutate_recode_attrs.R:442
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = value, values = 1)
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 37. Error: Recoding node attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% set_node_attrs(node_attr = value, 
         values = 1) %>% set_node_attrs(node_attr = shape, values = "square") at testthat/test-copy_drop_mutate_recode_attrs.R:509
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_node_attrs(., node_attr = value, values = 1)
  9: rlang::UQ(node_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(node_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 38. Error: Recoding edge attributes is possible (@test-copy_drop_mutate_recod
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% add_edges_w_string(edges = "1->3 2->4 1->4 3->2") %>% 
         set_edge_attrs(edge_attr = value, values = c(1, 1, 2, 3)) %>% set_edge_attrs(edge_attr = color, 
         values = c("red", "red", "blue", "black")) at testthat/test-copy_drop_mutate_recode_attrs.R:706
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = value, values = c(1, 1, 2, 3))
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 39. Error: a random graph can be made to various specifications (@test-create
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(all(get_node_ids(random_graph_10_15_directed) == 1:10)) at testthat/test-create_random_graph.R:24
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_node_ids(random_graph_10_15_directed)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 40. Error: a subgraph can be created and such an object is correct (@test-cre
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_nodes(conditions = value > 3) at testthat/test-create_subgraph.R:29
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: select_nodes(., conditions = value > 3)
  10: rlang::UQ(conditions) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(conditions)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 41. Error: nodes and edges can be deleted from a graph (@test-delete_node_edg
  `UQ()` can only be used within a quasiquoted argument
  1: get_node_ids(graph) at testthat/test-delete_node_edge.R:31
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 42. Error: nodes and edges can be deleted from a graph via a selection (@test
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes(graph = graph, nodes = c(3, 4)) at testthat/test-delete_node_edge.R:178
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 43. Error: edges can be deleted from a graph using node label values (@test-d
  `UQ()` can only be used within a quasiquoted argument
  1: graph_labeled_nodes %>% delete_edge(from = "one", to = "two") at testthat/test-delete_node_edge.R:270
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: delete_edge(., from = "one", to = "two")
  10: ifelse(all(c(from_id, to_id) %in% get_node_ids(graph)), TRUE, FALSE)
  11: c(from_id, to_id) %in% get_node_ids(graph)
  12: get_node_ids(graph)
  13: rlang::UQ(conditions) %>% paste()
  14: eval(lhs, parent, parent)
  15: eval(lhs, parent, parent)
  16: rlang::UQ(conditions)
  17: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 44. Error: a specified edge can be queried for presence in a graph (@test-edg
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(edge_present(graph = graph, from = 1, to = 3)) at testthat/test-edge_present.R:20
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: edge_present(graph = graph, from = 1, to = 3)
  5: ifelse(all(c(from, to) %in% get_node_ids(graph)), TRUE, FALSE)
  6: c(from, to) %in% get_node_ids(graph)
  7: get_node_ids(graph)
  8: rlang::UQ(conditions) %>% paste()
  9: eval(lhs, parent, parent)
  10: eval(lhs, parent, parent)
  11: rlang::UQ(conditions)
  12: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 45. Error: a specified edge relationship can be read from graph objects (@tes
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(edge_rel(graph = graph, from = 1, to = 4, action = "read"), "leading_to") at testthat/test-edge_relationship.R:43
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: edge_rel(graph = graph, from = 1, to = 4, action = "read")
  5: edge_present(graph = graph, from = from, to = to)
  6: ifelse(all(c(from, to) %in% get_node_ids(graph)), TRUE, FALSE)
  7: c(from, to) %in% get_node_ids(graph)
  8: get_node_ids(graph)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 46. Error: removing an edge relationship is possible (@test-edge_relationship
  `UQ()` can only be used within a quasiquoted argument
  1: edge_rel(graph = graph, from = 1, to = 4, action = "delete") at testthat/test-edge_relationship.R:128
  2: edge_present(graph = graph, from = from, to = to)
  3: ifelse(all(c(from, to) %in% get_node_ids(graph)), TRUE, FALSE)
  4: c(from, to) %in% get_node_ids(graph)
  5: get_node_ids(graph)
  6: rlang::UQ(conditions) %>% paste()
  7: eval(lhs, parent, parent)
  8: eval(lhs, parent, parent)
  9: rlang::UQ(conditions)
  10: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 47. Error: edge relationships can be set for edges in graph objects (@test-ed
  `UQ()` can only be used within a quasiquoted argument
  1: edge_rel(graph = graph_no_rel, from = 1, to = 4, action = "add", value = "new_rel") at testthat/test-edge_relationship.R:254
  2: edge_present(graph = graph, from = from, to = to)
  3: ifelse(all(c(from, to) %in% get_node_ids(graph)), TRUE, FALSE)
  4: c(from, to) %in% get_node_ids(graph)
  5: get_node_ids(graph)
  6: rlang::UQ(conditions) %>% paste()
  7: eval(lhs, parent, parent)
  8: eval(lhs, parent, parent)
  9: rlang::UQ(conditions)
  10: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 48. Error: Getting aggregated indegree values is possible (@test-get_aggregat
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_agg_degree_in(graph = graph, agg = "mean"), 2.2) at testthat/test-get_aggregate_degree.R:14
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_agg_degree_in(graph = graph, agg = "mean")
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 49. Error: Getting aggregated outdegree values is possible (@test-get_aggrega
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_agg_degree_out(graph = graph, agg = "mean"), 2.2) at testthat/test-get_aggregate_degree.R:128
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_agg_degree_out(graph = graph, agg = "mean")
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 50. Error: Getting aggregated total degree values is possible (@test-get_aggr
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_agg_degree_total(graph = graph, agg = "mean"), 4.4) at testthat/test-get_aggregate_degree.R:242
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_agg_degree_total(graph = graph, agg = "mean")
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  Modularity is implemented for undirected graphs only.
  ── 51. Error: Getting graph eccentricity is possible (@test-get_graph_metrics.R#
  `UQ()` can only be used within a quasiquoted argument
  1: get_eccentricity(graph) at testthat/test-get_graph_metrics.R:202
  2: get_node_ids(graph)
  3: rlang::UQ(conditions) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(conditions)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 52. Error: Getting graph periphery is possible (@test-get_graph_metrics.R#234
  `UQ()` can only be used within a quasiquoted argument
  1: get_periphery(graph) at testthat/test-get_graph_metrics.R:234
  2: get_eccentricity(graph)
  3: get_node_ids(graph)
  4: rlang::UQ(conditions) %>% paste()
  5: eval(lhs, parent, parent)
  6: eval(lhs, parent, parent)
  7: rlang::UQ(conditions)
  8: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 53. Error: Getting the minimum cut between nodes is possible (@test-get_graph
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_cycle(n = 5) %>% select_edges() %>% set_edge_attrs_ws(edge_attr = "capacity", 
         value = rnorm(n = edge_count(.), mean = 5, sd = 1)) %>% clear_selection() at testthat/test-get_graph_metrics.R:415
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 54. Error: Identifying the graph as weighted is possible (@test-get_graph_pro
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_cycle(n = 5) %>% select_edges() %>% set_edge_attrs_ws(edge_attr = "weight", 
         value = c(3, 5, 2, 9, 6)) %>% clear_selection() at testthat/test-get_graph_properties.R:114
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 55. Error: Getting authority centrality is possible (@test-get_node_calculati
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 10, m = 22, set_seed = 1) %>% select_edges() %>% set_edge_attrs_ws(edge_attr = "weight", 
         value = rnorm(n = 22, mean = 3, sd = 0.5)) %>% clear_selection() at testthat/test-get_node_calculations.R:365
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 56. Error: Getting eigenvector centrality is possible (@test-get_node_calcula
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 10, m = 22, set_seed = 23) %>% select_edges() %>% set_edge_attrs_ws(edge_attr = "weight", 
         value = rnorm(n = 22, mean = 3, sd = 0.5)) %>% clear_selection() at testthat/test-get_node_calculations.R:455
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 57. Error: Getting constraint values is possible (@test-get_node_calculations
  `UQ()` can only be used within a quasiquoted argument
  1: get_constraint(graph, nodes = 1:5) at testthat/test-get_node_calculations.R:571
  2: as.character(nodes) %in% get_node_ids(graph)
  3: get_node_ids(graph)
  4: rlang::UQ(conditions) %>% paste()
  5: eval(lhs, parent, parent)
  6: eval(lhs, parent, parent)
  7: rlang::UQ(conditions)
  8: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 58. Error: getting node IDs from various objects is possible (@test-get_nodes
  `UQ()` can only be used within a quasiquoted argument
  1: get_node_ids(graph) at testthat/test-get_nodes_edges.R:33
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 59. Error: getting node IDs associated within a graph's edges is possible (@t
  `UQ()` can only be used within a quasiquoted argument
  1: get_edges(graph, return_type = "list") at testthat/test-get_nodes_edges.R:135
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 60. Error: getting edge information from an edge data frame is possible (@tes
  `UQ()` can only be used within a quasiquoted argument
  1: get_edges(x = edges, return_type = "vector") at testthat/test-get_nodes_edges.R:227
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 61. Error: getting edge information from a graph with no edges is possible  (
  `UQ()` can only be used within a quasiquoted argument
  1: get_edges(x = graph_no_edges, return_type = "vector") at testthat/test-get_nodes_edges.R:307
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 62. Error: getting connected nodes is possible (@test-get_nodes_edges.R#350) 
  `UQ()` can only be used within a quasiquoted argument
  1: get_all_connected_nodes(graph = graph, node = 1) at testthat/test-get_nodes_edges.R:350
  2: node %in% get_node_ids(graph)
  3: get_node_ids(graph)
  4: rlang::UQ(conditions) %>% paste()
  5: eval(lhs, parent, parent)
  6: eval(lhs, parent, parent)
  7: rlang::UQ(conditions)
  8: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 63. Error: getting edge IDs from graph objects is possible (@test-get_nodes_e
  `UQ()` can only be used within a quasiquoted argument
  1: expect_equal(get_edge_ids(graph), c(1, 2, 3)) at testthat/test-get_nodes_edges.R:402
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_edge_ids(graph)
  5: rlang::UQ(conditions) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(conditions)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 64. Error: getting lists of node IDs using `get_paths()` is possible (@test-g
  `UQ()` can only be used within a quasiquoted argument
  1: get_paths(graph = graph, from = 1) at testthat/test-get_paths.R:21
  2: get_successors(graph, paths[[i]][length(paths[[i]])])
  3: node_present(graph, node)
  4: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  5: node %in% get_node_ids(graph)
  6: get_node_ids(graph)
  7: rlang::UQ(conditions) %>% paste()
  8: eval(lhs, parent, parent)
  9: eval(lhs, parent, parent)
  10: rlang::UQ(conditions)
  11: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 65. Error: getting or selecting the last edges created is possible (@test-get
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% delete_edge(id = 5) at testthat/test-get_select_last_nodes_edges_created.R:56
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: delete_edge(., id = 5)
  10: ifelse(all(c(from_id, to_id) %in% get_node_ids(graph)), TRUE, FALSE)
  11: c(from_id, to_id) %in% get_node_ids(graph)
  12: get_node_ids(graph)
  13: rlang::UQ(conditions) %>% paste()
  14: eval(lhs, parent, parent)
  15: eval(lhs, parent, parent)
  16: rlang::UQ(conditions)
  17: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 66. Error: getting or selecting the last nodes created is possible (@test-get
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_last_nodes_created() at testthat/test-get_select_last_nodes_edges_created.R:93
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: select_last_nodes_created(.)
  10: select_nodes(graph = graph, nodes = node_id_values)
  11: rlang::UQ(conditions) %>% paste()
  12: eval(lhs, parent, parent)
  13: eval(lhs, parent, parent)
  14: rlang::UQ(conditions)
  15: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 67. Error: graph actions can be triggered to modify the graph (@test-graph_ac
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 5, m = 10, set_seed = 23) %>% drop_node_attrs(node_attr = "value") at testthat/test-graph_actions.R:176
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: drop_node_attrs(., node_attr = "value")
  10: rlang::UQ(node_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 68. Error: Getting all neighbors of one or more nodes is possible (@test-neig
  `UQ()` can only be used within a quasiquoted argument
  1: get_nbrs(graph = random_graph, nodes = 5) at testthat/test-neighbors.R:13
  2: get_predecessors(graph, node = nodes[i])
  3: node_present(graph, node)
  4: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  5: node %in% get_node_ids(graph)
  6: get_node_ids(graph)
  7: rlang::UQ(conditions) %>% paste()
  8: eval(lhs, parent, parent)
  9: eval(lhs, parent, parent)
  10: rlang::UQ(conditions)
  11: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 69. Error: Getting non-neighbors of a node is possible (@test-neighbors.R#52)
  `UQ()` can only be used within a quasiquoted argument
  1: get_non_nbrs(graph = random_graph, node = 5) at testthat/test-neighbors.R:52
  2: get_predecessors(graph, node = node)
  3: node_present(graph, node)
  4: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  5: node %in% get_node_ids(graph)
  6: get_node_ids(graph)
  7: rlang::UQ(conditions) %>% paste()
  8: eval(lhs, parent, parent)
  9: eval(lhs, parent, parent)
  10: rlang::UQ(conditions)
  11: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 70. Error: Getting common neighbors of 2 or more nodes is possible (@test-nei
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(is.na(get_common_nbrs(graph = random_graph, nodes = c(5, 7)))) at testthat/test-neighbors.R:75
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_common_nbrs(graph = random_graph, nodes = c(5, 7))
  5: sort(get_predecessors(graph, node = nodes[i]))
  6: get_predecessors(graph, node = nodes[i])
  7: node_present(graph, node)
  8: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  9: node %in% get_node_ids(graph)
  10: get_node_ids(graph)
  11: rlang::UQ(conditions) %>% paste()
  12: eval(lhs, parent, parent)
  13: eval(lhs, parent, parent)
  14: rlang::UQ(conditions)
  15: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 71. Error: Getting similar neighbors of a node is possible (@test-neighbors.R
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(is.na(get_similar_nbrs(graph = random_graph, node = 2, node_attr = value))) at testthat/test-neighbors.R:101
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_similar_nbrs(graph = random_graph, node = 2, node_attr = value)
  5: rlang::UQ(node_attr) %>% paste()
  6: eval(lhs, parent, parent)
  7: eval(lhs, parent, parent)
  8: rlang::UQ(node_attr)
  9: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 72. Error: getting a node count for a graph is possible (@test-node_edge_coun
  `UQ()` can only be used within a quasiquoted argument
  1: node_count(graph = graph, type = TRUE) at testthat/test-node_edge_count.R:32
  2: get_node_ids(graph)
  3: rlang::UQ(conditions) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(conditions)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 73. Error: a specified node can be queried for presence in a graph (@test-nod
  `UQ()` can only be used within a quasiquoted argument
  1: expect_true(node_present(graph = graph, node = 1)) at testthat/test-node_present.R:12
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: node_present(graph = graph, node = 1)
  5: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  6: node %in% get_node_ids(graph)
  7: get_node_ids(graph)
  8: rlang::UQ(conditions) %>% paste()
  9: eval(lhs, parent, parent)
  10: eval(lhs, parent, parent)
  11: rlang::UQ(conditions)
  12: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 74. Error: a specified node type can be read from graph objects (@test-node_t
  `UQ()` can only be used within a quasiquoted argument
  1: node_type(graph = graph, node = 1, action = "read") at testthat/test-node_type.R:14
  2: node_present(graph = graph, node = node)
  3: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  4: node %in% get_node_ids(graph)
  5: get_node_ids(graph)
  6: rlang::UQ(conditions) %>% paste()
  7: eval(lhs, parent, parent)
  8: eval(lhs, parent, parent)
  9: rlang::UQ(conditions)
  10: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 75. Error: getting a node's predecessors/successors is possible (@test-predec
  `UQ()` can only be used within a quasiquoted argument
  1: expect_is(get_predecessors(graph = graph, node = 26), "integer") at testthat/test-predecessors_successors.R:33
  2: quasi_label(enquo(object), label)
  3: eval_bare(get_expr(quo), get_env(quo))
  4: get_predecessors(graph = graph, node = 26)
  5: node_present(graph, node)
  6: ifelse(node %in% get_node_ids(graph), TRUE, FALSE)
  7: node %in% get_node_ids(graph)
  8: get_node_ids(graph)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 76. Error: rescaling node attributes in a graph is possible (@test-rescale_no
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% rescale_node_attrs(node_attr_from = value) at testthat/test-rescale_node_edge_attrs.R:13
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: rescale_node_attrs(., node_attr_from = value)
  10: rlang::UQ(node_attr_from) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr_from)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 77. Error: rescaling edge attributes in a graph is possible (@test-rescale_no
  `UQ()` can only be used within a quasiquoted argument
  1: create_random_graph(n = 5, m = 7, set_seed = 23) %>% set_edge_attrs(edge_attr = weight, 
         values = rnorm(edge_count(.), 5)) at testthat/test-rescale_node_edge_attrs.R:65
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_edge_attrs(., edge_attr = weight, values = rnorm(edge_count(.), 5))
  10: rlang::UQ(edge_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(edge_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 78. Error: selecting a node in a graph is possible (@test-selections.R#28)  ─
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes(graph = graph, nodes = c(1, 3)) at testthat/test-selections.R:28
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 79. Error: selecting an edge in a graph is possible (@test-selections.R#198) 
  `UQ()` can only be used within a quasiquoted argument
  1: select_edges(graph = graph, from = c(1, 2), to = c(4, 3)) at testthat/test-selections.R:198
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 80. Error: selecting nodes in a neighborhood is possible (@test-selections.R#
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes_in_neighborhood(graph = graph, node = 6, distance = 2) at testthat/test-selections.R:479
  2: get_edges(graph, return_type = "df")
  3: rlang::UQ(conditions) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(conditions)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 81. Error: getting a selection is possible (@test-selections.R#547)  ────────
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_nodes() %>% get_selection() at testthat/test-selections.R:547
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 82. Error: inverting a selection is possible (@test-selections.R#577)  ──────
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_nodes(nodes = 1) %>% select_nodes(nodes = 2) at testthat/test-selections.R:577
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(., nodes = 1)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 83. Error: getting/clearing a selection is possible (@test-selections.R#640) 
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_nodes() at testthat/test-selections.R:640
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: select_nodes(.)
  10: rlang::UQ(conditions) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(conditions)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 84. Error: Setting a time for the graph can be done (@test-set_get_graph_attr
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% select_nodes() %>% set_graph_time("2015-10-25 15:23:00") at testthat/test-set_get_graph_attrs.R:77
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 85. Error: setting node attributes is possible (@test-set_get_node_edge_attrs
  `UQ()` can only be used within a quasiquoted argument
  1: set_node_attrs(x = graph, nodes = 1, node_attr = value, values = 5) at testthat/test-set_get_node_edge_attrs.R:11
  2: rlang::UQ(node_attr) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(node_attr)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 86. Error: setting edge attributes is possible (@test-set_get_node_edge_attrs
  `UQ()` can only be used within a quasiquoted argument
  1: set_edge_attrs(x = graph, from = 1, to = 2, edge_attr = value, values = 5) at testthat/test-set_get_node_edge_attrs.R:164
  2: rlang::UQ(edge_attr) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(edge_attr)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 87. Error: Getting node attributes is possible (@test-set_get_node_edge_attrs
  `UQ()` can only be used within a quasiquoted argument
  1: get_node_attrs(graph = random_graph, node_attr = value) at testthat/test-set_get_node_edge_attrs.R:274
  2: (rlang::UQ(node_attr) %>% paste())[2] %in% c("id", "nodes")
  3: rlang::UQ(node_attr) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(node_attr)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 88. Error: Getting edge attributes is possible (@test-set_get_node_edge_attrs
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% {
         edges <- create_edge_df(from = c(1, 2, 1, 4), to = c(2, 3, 4, 3), rel = "rel")
         add_edge_df(graph = ., edge_df = edges)
     } %>% set_edge_attrs(edge_attr = value, values = 1.6, from = 1, to = 2) %>% set_edge_attrs(edge_attr = value, 
         values = 4.3, from = 1, to = 4) %>% set_edge_attrs(edge_attr = value, values = 2.9, 
         from = 2, to = 3) %>% set_edge_attrs(edge_attr = value, values = 8.4, from = 4, 
         to = 3) at testthat/test-set_get_node_edge_attrs.R:337
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = value, values = 1.6, from = 1, to = 2)
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 89. Error: Getting node attributes with a selection is possible (@test-set_ge
  `UQ()` can only be used within a quasiquoted argument
  1: get_node_attrs_ws(graph = graph, node_attr = value) at testthat/test-set_get_node_edge_attrs.R:466
  2: (rlang::UQ(node_attr) %>% paste())[2] %in% c("id", "nodes")
  3: rlang::UQ(node_attr) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(node_attr)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 90. Error: Getting edge attributes with a selection is possible (@test-set_ge
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_n_nodes(n = 4) %>% {
         edges <- create_edge_df(from = c(1, 2, 1, 4), to = c(2, 3, 4, 3), rel = "rel")
         add_edge_df(graph = ., edge_df = edges)
     } %>% set_edge_attrs(edge_attr = value, values = 1.6, from = 1, to = 2) %>% set_edge_attrs(edge_attr = value, 
         values = 4.3, from = 1, to = 4) %>% set_edge_attrs(edge_attr = value, values = 2.9, 
         from = 2, to = 3) %>% set_edge_attrs(edge_attr = value, values = 8.4, from = 4, 
         to = 3) %>% select_edges(from = c(1, 2), to = c(2, 3)) at testthat/test-set_get_node_edge_attrs.R:512
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: set_edge_attrs(., edge_attr = value, values = 1.6, from = 1, to = 2)
  9: rlang::UQ(edge_attr) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(edge_attr)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 91. Error: node attributes can be chosen for display (@test-set_node_attr_to_
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% set_node_attr_to_display(nodes = 1:3, attr = value, default = NA) at testthat/test-set_node_attr_to_display.R:14
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_node_attr_to_display(., nodes = 1:3, attr = value, default = NA)
  10: rlang::UQ(attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 92. Error: altering several nodes' positions is possible (@test-set_node_posi
  `UQ()` can only be used within a quasiquoted argument
  1: select_nodes(graph_1) at testthat/test-set_node_positions.R:100
  2: rlang::UQ(conditions) %>% paste()
  3: eval(lhs, parent, parent)
  4: eval(lhs, parent, parent)
  5: rlang::UQ(conditions)
  6: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 93. Error: the dice similarity algorithm is functional (@test-similarity_meas
  `UQ()` can only be used within a quasiquoted argument
  1: get_dice_similarity(graph = graph, nodes = 5:7, direction = "all") at testthat/test-similarity_measures.R:13
  2: nodes %in% get_node_ids(graph)
  3: get_node_ids(graph)
  4: rlang::UQ(conditions) %>% paste()
  5: eval(lhs, parent, parent)
  6: eval(lhs, parent, parent)
  7: rlang::UQ(conditions)
  8: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 94. Error: the Jaccard similarity algorithm is functional (@test-similarity_m
  `UQ()` can only be used within a quasiquoted argument
  1: get_jaccard_similarity(graph = graph, nodes = 5:7, direction = "all") at testthat/test-similarity_measures.R:157
  2: nodes %in% get_node_ids(graph)
  3: get_node_ids(graph)
  4: rlang::UQ(conditions) %>% paste()
  5: eval(lhs, parent, parent)
  6: eval(lhs, parent, parent)
  7: rlang::UQ(conditions)
  8: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 95. Error: Reversing the graph edges is possible (@test-transform_graph.R#62)
  `UQ()` can only be used within a quasiquoted argument
  1: rev_edge_dir(graph) at testthat/test-transform_graph.R:62
  2: get_edges(graph, return_type = "df")
  3: rlang::UQ(conditions) %>% paste()
  4: eval(lhs, parent, parent)
  5: eval(lhs, parent, parent)
  6: rlang::UQ(conditions)
  7: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 96. Error: simple traversals are possible (@test-traversals.R#25)  ──────────
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_nodes(nodes = 1) %>% trav_out() %>% trav_out() %>% trav_out() at testthat/test-traversals.R:25
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(., nodes = 1)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 97. Error: selective traversals with `trav_out()` are possible (@test-travers
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:178
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 98. Error: selective traversals with `trav_in()` are possible (@test-traversa
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:333
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 99. Error: selective traversals with `trav_out_edge()` are possible (@test-tr
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:493
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 100. Error: selective traversals with `trav_in_edge()` are possible (@test-tr
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:655
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 101. Error: selective traversals with `trav_in_node()` are possible (@test-tr
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:818
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 102. Error: selective traversals with `trav_out_node()` are possible (@test-t
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:995
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 103. Error: selective traversals with `trav_both()` are possible (@test-trave
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = 5) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% clear_selection() at testthat/test-traversals.R:1171
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 104. Error: selective traversals with `trav_both_edge()` are possible (@test-
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% add_node() %>% add_node() %>% add_node() %>% add_edge(from = 1, 
         to = 2) %>% add_edge(from = 2, to = 3) %>% add_edge(from = 3, to = 4) %>% select_nodes() %>% 
         set_node_attrs_ws(node_attr = type, value = "circle") %>% clear_selection() %>% 
         select_nodes_by_id(nodes = c(2, 3)) %>% set_node_attrs_ws(node_attr = data_value, 
         value = 10) %>% clear_selection() %>% select_nodes_by_id(nodes = 4) %>% set_node_attrs_ws(node_attr = shape, 
         value = "square") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 1) %>% set_node_attrs_ws(node_attr = shape, 
         value = "triangle") %>% set_node_attrs_ws(node_attr = data_value, value = 5) %>% 
         clear_selection() %>% select_edges() %>% set_edge_attrs_ws(edge_attr = data_value, 
         value = c(1, 2, 3)) %>% set_edge_attrs_ws(edge_attr = rel, value = "related_to") %>% 
         clear_selection() at testthat/test-traversals.R:1361
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 105. Error: traversing to reverse edges with an edge selection is possible (@
  `UQ()` can only be used within a quasiquoted argument
  1: graph %>% select_edges(from = 1, to = 4) %>% select_edges(from = 2, to = 3) at testthat/test-traversals.R:1470
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_edges(., from = 1, to = 4)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 106. Error: copying values with `trav_out_edge()` works (@test-traversals_cop
  `UQ()` can only be used within a quasiquoted argument
  1: graph_1 %>% rename_node_attrs(node_attr_from = value, node_attr_to = data) at testthat/test-traversals_copying_attr_vals.R:34
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: rename_node_attrs(., node_attr_from = value, node_attr_to = data)
  10: rlang::UQ(node_attr_from) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr_from)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 107. Error: copying values with `trav_in_edge()` works (@test-traversals_copy
  `UQ()` can only be used within a quasiquoted argument
  1: graph_1 %>% rename_node_attrs("value", "data") at testthat/test-traversals_copying_attr_vals.R:153
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: rename_node_attrs(., "value", "data")
  10: rlang::UQ(node_attr_from) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr_from)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 108. Error: copying values with `trav_both_edge()` works (@test-traversals_co
  `UQ()` can only be used within a quasiquoted argument
  1: graph_1 %>% rename_node_attrs(node_attr_from = value, node_attr_to = data) at testthat/test-traversals_copying_attr_vals.R:268
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: rename_node_attrs(., node_attr_from = value, node_attr_to = data)
  10: rlang::UQ(node_attr_from) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr_from)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 109. Error: copying values with `trav_both()` works (@test-traversals_copying
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_path(n = 5) %>% select_nodes_by_id(nodes = c(2, 4)) %>% set_node_attrs_ws(node_attr = value, 
         value = 5) at testthat/test-traversals_copying_attr_vals.R:359
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: withVisible(function_list[[k]](value))
  8: function_list[[k]](value)
  9: set_node_attrs_ws(., node_attr = value, value = 5)
  10: rlang::UQ(node_attr) %>% paste()
  11: eval(lhs, parent, parent)
  12: eval(lhs, parent, parent)
  13: rlang::UQ(node_attr)
  14: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 110. Error: copying values with `trav_in()` works (@test-traversals_copying_a
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% select_nodes() %>% add_n_nodes_ws(n = 2, direction = "from") %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 2:3) %>% set_node_attrs_ws(node_attr = value, 
         value = 5) at testthat/test-traversals_copying_attr_vals.R:382
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 111. Error: copying values with `trav_out()` works (@test-traversals_copying_
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% select_nodes() %>% add_n_nodes_ws(n = 2, direction = "to") %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 2:3) %>% set_node_attrs_ws(node_attr = value, 
         value = 5) at testthat/test-traversals_copying_attr_vals.R:410
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 112. Error: copying values with `trav_out_node()` works (@test-traversals_cop
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% select_nodes() %>% add_n_nodes_ws(n = 2, direction = "from") %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 2) %>% set_node_attrs_ws(node_attr = value, 
         value = 8) %>% clear_selection() %>% select_edges_by_edge_id(edges = 1) %>% set_edge_attrs_ws(edge_attr = value, 
         value = 5) %>% clear_selection() %>% select_edges_by_edge_id(edges = 2) %>% set_edge_attrs_ws(edge_attr = value, 
         value = 5) %>% clear_selection() %>% select_edges() at testthat/test-traversals_copying_attr_vals.R:438
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ── 113. Error: copying values with `trav_in_node()` works (@test-traversals_copy
  `UQ()` can only be used within a quasiquoted argument
  1: create_graph() %>% add_node() %>% select_nodes() %>% add_n_nodes_ws(n = 2, direction = "to") %>% 
         clear_selection() %>% select_nodes_by_id(nodes = 2) %>% set_node_attrs_ws(node_attr = value, 
         value = 8) %>% clear_selection() %>% select_edges_by_edge_id(edges = 1) %>% set_edge_attrs_ws(edge_attr = value, 
         value = 5) %>% clear_selection() %>% select_edges_by_edge_id(edges = 2) %>% set_edge_attrs_ws(edge_attr = value, 
         value = 5) %>% clear_selection() %>% select_edges() at testthat/test-traversals_copying_attr_vals.R:478
  2: withVisible(eval(quote(`_fseq`(`_lhs`)), env, env))
  3: eval(quote(`_fseq`(`_lhs`)), env, env)
  4: eval(quote(`_fseq`(`_lhs`)), env, env)
  5: `_fseq`(`_lhs`)
  6: freduce(value, `_function_list`)
  7: function_list[[i]](value)
  8: select_nodes(.)
  9: rlang::UQ(conditions) %>% paste()
  10: eval(lhs, parent, parent)
  11: eval(lhs, parent, parent)
  12: rlang::UQ(conditions)
  13: abort("`UQ()` can only be used within a quasiquoted argument")
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 884 SKIPPED: 0 FAILED: 113
  1. Error: forward edges can be added given a selection of edges (@test-add_forward_reverse_edges.R#20) 
  2. Error: reverse edges can be added given a selection of edges (@test-add_forward_reverse_edges.R#65) 
  3. Error: Adding a balanced tree is possible (@test-add_graphs.R#26) 
  4. Error: Adding a cycle is possible (@test-add_graphs.R#119) 
  5. Error: Adding a path is possible (@test-add_graphs.R#264) 
  6. Error: Adding a prism is possible (@test-add_graphs.R#409) 
  7. Error: Adding a star is possible (@test-add_graphs.R#554) 
  8. Error: Adding a full graph is possible (@test-add_graphs.R#703) 
  9. Error: adding a node to a graph is possible (@test-add_node_edge.R#72) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted