Running 'testthat.R' [7s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > if (requireNamespace("testthat", quietly = TRUE)) {
  +   library(testthat)
  +   library(mlr3db)
  +   test_check("mlr3db")
  + }
  -- 1. Error: (unknown) (@test_train_predict.R#4)  ------------------------------
  not a function
  1: mlr3::mlr_learners$get("classif.featureless") at testthat/test_train_predict.R:4
  2: dictionary_get(self, key, ...)
  3: dictionary_initialize_item(key, obj, dots)
  4: do.call(constructor$new, cargs)
  5: (function (...) 
     {
         inherit <- get_inherit()
         if (!is.null(inherit)) {
             if (!inherits(inherit, "R6ClassGenerator")) 
                 stop("`inherit` must be a R6ClassGenerator.")
             if (!identical(portable, inherit$portable)) 
                 stop("Sub and superclass must both be portable or non-portable.")
             recursive_merge <- function(obj, which) {
                 if (is.null(obj)) 
                     return(NULL)
                 merge_vectors(recursive_merge(obj$get_inherit(), which), obj[[which]])
             }
             public_fields <- merge_vectors(recursive_merge(inherit, "public_fields"), 
                 public_fields)
             private_fields <- merge_vectors(recursive_merge(inherit, "private_fields"), 
                 private_fields)
         }
         if (class) {
             classes <- c(classname, get_superclassnames(inherit), "R6")
         }
         else {
             classes <- NULL
         }
         has_priv <- has_private()
         if (portable) {
             if (has_priv) 
                 private_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             else private_bind_env <- NULL
             public_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             enclos_env <- new.env(parent = parent_env, hash = FALSE)
         }
         else {
             if (has_priv) {
                 private_bind_env <- new.env(parent = parent_env, hash = FALSE)
                 public_bind_env <- new.env(parent = private_bind_env, hash = FALSE)
             }
             else {
                 private_bind_env <- NULL
                 public_bind_env <- new.env(parent = parent_env, hash = FALSE)
             }
             enclos_env <- public_bind_env
         }
         enclos_env$self <- public_bind_env
         if (has_priv) 
             enclos_env$private <- private_bind_env
         public_methods <- assign_func_envs(public_methods, enclos_env)
         if (has_priv) 
             private_methods <- assign_func_envs(private_methods, enclos_env)
         if (!is.null(active)) 
             active <- assign_func_envs(active, enclos_env)
         if (length(debug_names) > 0) {
             lapply(public_methods[names(public_methods) %in% debug_names], base::debug)
             lapply(private_methods[names(private_methods) %in% debug_names], base::debug)
             lapply(active[names(active) %in% debug_names], base::debug)
         }
         if (!is.null(inherit)) {
             if (portable) {
                 super_struct <- create_super_env(inherit, public_bind_env, private_bind_env, 
                     portable = TRUE)
             }
             else {
                 super_struct <- create_super_env(inherit, public_bind_env, portable = FALSE)
             }
             enclos_env$super <- super_struct$bind_env
             public_methods <- merge_vectors(super_struct$public_methods, public_methods)
             private_methods <- merge_vectors(super_struct$private_methods, private_methods)
             active <- merge_vectors(super_struct$active, active)
         }
         list2env2(public_methods, envir = public_bind_env)
         list2env2(public_fields, envir = public_bind_env)
         if (has_priv) {
             list2env2(private_methods, envir = private_bind_env)
             list2env2(private_fields, envir = private_bind_env)
         }
         if (!is.null(active)) {
             for (name in names(active)) {
                 makeActiveBinding(name, active[[name]], public_bind_env)
             }
         }
         public_bind_env$.__enclos_env__ <- enclos_env
         if (lock_objects) {
             if (has_priv) 
                 lockEnvironment(private_bind_env)
             lockEnvironment(public_bind_env)
         }
         if (has_priv) {
             for (name in names(private_methods)) lockBinding(name, private_bind_env)
         }
         for (name in names(public_methods)) lockBinding(name, public_bind_env)
         class(public_bind_env) <- classes
         if (is.function(.subset2(public_bind_env, "initialize"))) {
             .subset2(public_bind_env, "initialize")(...)
         }
         else if (length(list(...)) != 0) {
             stop("Called new() with arguments, but there is no initialize method.")
         }
         if (is.function(.subset2(public_bind_env, "finalize"))) {
             finalizer_wrapper <- function(e) {
                 .subset2(e, "finalize")()
             }
             environment(finalizer_wrapper) <- baseenv()
             reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
         }
         if (has_priv) {
             if (is.function(.subset2(private_bind_env, "finalize"))) {
                 finalizer_wrapper <- function(e) {
                     .subset2(e, ".__enclos_env__")$private$finalize()
                 }
                 environment(finalizer_wrapper) <- baseenv()
                 reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
             }
         }
         public_bind_env
     })()
  6: .subset2(public_bind_env, "initialize")(...)
  7: ParamSet$new(list(ParamFct$new("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", tags = "predict")))
  8: .subset2(public_bind_env, "initialize")(...)
  9: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  10: map(params, function(p) p$clone(deep = TRUE))
  11: lapply(.x, .f, ...)
  12: FUN(X[[i]], ...)
  13: p$clone(deep = TRUE)
  14: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  15: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  == testthat results  ===========================================================
  [ OK: 282 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 1 ]
  1. Error: (unknown) (@test_train_predict.R#4) 
  
  Error: testthat unit tests failed
  Execution halted