Running 'testthat.R' [10s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(datastructures)
  Loading required package: Rcpp
  
  Attaching package: 'datastructures'
  
  The following objects are masked from 'package:utils':
  
      head, stack
  
  The following object is masked from 'package:base':
  
      get
  
  > library(testthat)
  > 
  > test_check("datastructures")
  -- 1. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#7
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 2. Error: (unknown) (@tests_map_unordered_map.R#73)  ------------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 3. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#7
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 4. Error: (unknown) (@tests_map_unordered_map.R#73)  ------------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 5. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#7
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 6. Error: (unknown) (@tests_map_unordered_map.R#73)  ------------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 7. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#7
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 8. Error: (unknown) (@tests_map_unordered_map.R#73)  ------------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 9. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#7
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 10. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 11. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 12. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 13. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 14. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 15. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 16. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 17. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 18. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 19. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 20. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  -- 21. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#
  attempt to apply non-function
  1: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  2: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  3: .findInheritedMethods(classes, fdef, mtable)
  4: outerLabels(labels, allLabels)
  5: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  6: rep.int(1L:n, rep.int(m, n))
  7: rep.int(m, n)
  8: (function (x) 
     x$.self$finalize())(<environment>)
  
  -- 22. Error: (unknown) (@tests_map_unordered_map.R#73)  -----------------------
  no function to return from, jumping to top level
  1: test_that("unordered map insert/get matrix works", {
         for (cm in maps) {
             h <- cm("numeric", "numeric")
             m <- matrix(rnorm(10), 2)
             r <- c(1, 2)
             h <- insert(h, r, m)
             expect_equal(get(h, 1)[[1]], m[1, ])
         }
     }) at testthat/tests_map_unordered_map.R:73
  2: test_code(desc, code, env = parent.frame())
  3: tryCatch(withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error), error = handle_fatal, skip = function(e) {
     })
  4: tryCatchList(expr, classes, parentenv, handlers)
  5: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], 
         parentenv, handlers[[nh]])
  6: doTryCatch(return(expr), name, parentenv, handler)
  7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  8: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  9: doTryCatch(return(expr), name, parentenv, handler)
  10: withCallingHandlers({
         eval(code, test_env)
         if (!handled && !is.null(test)) {
             skip_empty()
         }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
         message = handle_message, error = handle_error)
  11: eval(code, test_env)
  12: eval(expr, envir, enclos)
  13: insert(h, r, m) at testthat/tests_map_unordered_map.R:79
  14: (function (classes, fdef, mtable) 
     {
         methods <- .findInheritedMethods(classes, fdef, mtable)
         if (length(methods) == 1L) 
             return(methods[[1L]])
         else if (length(methods) == 0L) {
             cnames <- paste0("\"", vapply(classes, as.character, ""), "\"", collapse = ", ")
             stop(gettextf("unable to find an inherited method for function %s for signature %s", 
                 sQuote(fdef@generic), sQuote(cnames)), domain = NA)
         }
         else stop("Internal error in finding inherited methods; didn't return a unique method", 
             domain = NA)
     })(list(structure("hashmap", package = "datastructures"), "numeric", "matrix"), structure(function (obj, 
         x, y) 
     {
         standardGeneric("insert")
     }, generic = structure("insert", package = "datastructures"), package = "datastructures", group = list(), valueClass = character(0), signature = c("obj", 
     "x", "y"), default = `\001NULL\001`, skeleton = (function (obj, x, y) 
     stop("invalid call in method dispatch to 'insert' (no default method)", domain = NA))(obj, 
         x, y), class = structure("nonstandardGenericFunction", package = "methods")), 
         <environment>)
  15: .findInheritedMethods(classes, fdef, mtable)
  16: outerLabels(labels, allLabels)
  17: paste(labels[rep.int(1L:n, rep.int(m, n))], new[rep.int(1L:m, n)], sep = "#")
  18: rep.int(1L:n, rep.int(m, n))
  19: rep.int(m, n)
  20: (function (x) 
     x$.self$finalize())(<environment>)
  
  Error in (function (x)  : 
    no function to return from, jumping to top level
  == testthat results  ===========================================================
  OK: 113 SKIPPED: 0 FAILED: 22
  1. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#79) 
  2. Error: (unknown) (@tests_map_unordered_map.R#73) 
  3. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#79) 
  4. Error: (unknown) (@tests_map_unordered_map.R#73) 
  5. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#79) 
  6. Error: (unknown) (@tests_map_unordered_map.R#73) 
  7. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#79) 
  8. Error: (unknown) (@tests_map_unordered_map.R#73) 
  9. Error: unordered map insert/get matrix works (@tests_map_unordered_map.R#79) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted