Running ‘testthat.R’ [3s/5s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(ggloop)
  > library(ggplot2)
  > 
  > test_check("ggloop")
  ── 1. Error: Test xydot.TF names (@test2.R#36)  ────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.TF), xydot.TF.dotnames, fixed = TRUE) at testthat/test2.R:36
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], fixed = dots[[3L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 2. Error: Test xydot.TT names (@test2.R#81)  ────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.TT), xydot.TT.dotnames, fixed = TRUE) at testthat/test2.R:81
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], fixed = dots[[3L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 3. Error: Teest xydot.FF names (@test2.R#126)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.FF), xydot.FF.dotnames, fixed = TRUE) at testthat/test2.R:126
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], fixed = dots[[3L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 4. Error: Test xydot.FT names (@test2.R#162)  ───────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.FT), xydot.FT.dotnames, fixed = TRUE) at testthat/test2.R:162
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]], fixed = dots[[3L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 5. Error: Test xydot.NAT names (@test2.R#195)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.NAT), xydot.NAT.dotnames) at testthat/test2.R:195
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 6. Error: Test xydot.NAF names (@test2.R#225)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydot.NAF), xydot.NAF.dotnames) at testthat/test2.R:225
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 7. Error: Test xydots.TF names (@test2.R#258)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.TF), xydots.TF.dotnames) at testthat/test2.R:258
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 8. Error: Test xydots.TT names (@test2.R#291)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.TT), xydots.TT.dotnames) at testthat/test2.R:291
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 9. Error: Test xydots.FF names (@test2.R#322)  ──────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.FF), xydots.FF.dotnames) at testthat/test2.R:322
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 10. Error: Test xydots.FT names (@test2.R#354)  ─────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.FT), xydots.FT.dotnames) at testthat/test2.R:354
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 11. Error: Test xydots.NAT names (@test2.R#386)  ────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.NAT), xydots.NAT.dotnames) at testthat/test2.R:386
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 12. Error: Test xydots.NAF names (@test2.R#418)  ────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xydots.NAF), xydots.NAF.dotnames) at testthat/test2.R:418
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 13. Error: Test xy.TF names (@test2.R#447)  ─────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.TF), xy.TF.xynames) at testthat/test2.R:447
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 14. Error: Test xy.TT names (@test2.R#469)  ─────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.TT), xy.TT.xynames) at testthat/test2.R:469
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 15. Error: Test xy.FF names (@test2.R#491)  ─────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.FF), xy.FF.xynames) at testthat/test2.R:491
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 16. Error: Test xy.FT names (@test2.R#513)  ─────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.FT), xy.FT.xynames) at testthat/test2.R:513
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 17. Error: Test xy.NAT names (@test2.R#535)  ────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.NAT), xy.NAT.xynames) at testthat/test2.R:535
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ── 18. Error: Test xy.NAF names (@test2.R#557)  ────────────────────────────────
  the argument has already been evaluated
  1: Map(expect_match, names(xy.NAF), xy.NAF.xynames) at testthat/test2.R:557
  2: mapply(FUN = f, ..., SIMPLIFY = FALSE)
  3: (function (object, regexp, perl = FALSE, fixed = FALSE, ..., all = TRUE, info = NULL, 
         label = NULL) 
     {
         if (fixed) 
             escape <- identity
         else escape <- escape_regex
         stopifnot(is.character(regexp), length(regexp) == 1)
         act <- quasi_label(enquo(object), label)
         stopifnot(is.character(act$val))
         if (length(object) == 0) {
             fail(sprintf("%s is empty.", act$lab))
         }
         matches <- grepl(regexp, act$val, perl = perl, fixed = fixed, ...)
         if (length(act$val) == 1) {
             values <- paste0("Actual value: \"", escape(encodeString(act$val)), "\"")
         }
         else {
             values <- paste0("Actual values:\n", paste0("* ", escape(encodeString(act$val)), 
                 collapse = "\n"))
         }
         expect(if (all) 
             all(matches)
         else any(matches), sprintf("%s does not match %s.\n%s", escape(act$lab), encodeString(regexp, 
             quote = "\""), values), info = info)
         invisible(act$val)
     })(dots[[1L]][[1L]], dots[[2L]][[1L]])
  4: quasi_label(enquo(object), label)
  5: force(quo)
  6: enquo(object)
  7: eval_bare(capture, caller_env())
  8: (function (x, strict = TRUE) 
     {
         caller_env <- parent.frame()
         if (identical(caller_env, globalenv())) {
             stop("must be called in a function")
         }
         if (missing(x)) {
             stop("argument \"x\" is missing")
         }
         .Call(rlang_capturearg, NULL, NULL, pairlist(caller_env, strict), get_env())
     })(object)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 88 SKIPPED: 0 FAILED: 18
  1. Error: Test xydot.TF names (@test2.R#36) 
  2. Error: Test xydot.TT names (@test2.R#81) 
  3. Error: Teest xydot.FF names (@test2.R#126) 
  4. Error: Test xydot.FT names (@test2.R#162) 
  5. Error: Test xydot.NAT names (@test2.R#195) 
  6. Error: Test xydot.NAF names (@test2.R#225) 
  7. Error: Test xydots.TF names (@test2.R#258) 
  8. Error: Test xydots.TT names (@test2.R#291) 
  9. Error: Test xydots.FF names (@test2.R#322) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted