Running 'testthat.R' [2s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > if (requireNamespace("testthat", quietly = TRUE)) {
  +   library(testthat)
  +   library(mlr3learners)
  +   test_check("mlr3learners")
  + }
  -- 1. Error: autotest (@test_classif_glmnet.R#4)  ------------------------------
  not a function
  1: mlr3::lrn("classif.glmnet") at testthat/test_classif_glmnet.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamDbl$new("alpha", default = 1, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new("nfolds", default = 10L, lower = 3L, tags = "train"), ParamFct$new("type.measure", 
             levels = c("deviance", "class", "auc", "mse", "mae"), default = "deviance", 
             tags = "train"), ParamDbl$new("s", lower = 0, special_vals = list("lambda.1se", 
             "lambda.min"), default = "lambda.1se", tags = "predict"), ParamInt$new("nlambda", 
             default = 100L, lower = 1L, tags = "train"), ParamDbl$new("lambda.min.ratio", 
             lower = 0, upper = 1, tags = "train"), ParamUty$new("lambda", tags = "train"), 
         ParamLgl$new("standardize", default = TRUE, tags = "train"), ParamLgl$new("intercept", 
             default = TRUE, tags = "train"), ParamDbl$new("thresh", default = 1e-07, 
             lower = 0, tags = "train"), ParamInt$new("dfmax", lower = 0L, tags = "train"), 
         ParamInt$new("pmax", lower = 0L, tags = "train"), ParamInt$new("exclude", lower = 1L, 
             tags = "train"), ParamDbl$new("penalty.factor", lower = 0, upper = 1, tags = "train"), 
         ParamUty$new("lower.limits", tags = "train"), ParamUty$new("upper.limits", tags = "train"), 
         ParamInt$new("maxit", default = 100000L, lower = 1L, tags = "train"), ParamFct$new("type.logistic", 
             levels = c("Newton", "modified.Newton"), tags = "train"), ParamFct$new("type.multinomial", 
             levels = c("ungrouped", "grouped"), tags = "train"), ParamDbl$new("fdev", 
             default = 1e-05, lower = 0, upper = 1, tags = "train"), ParamDbl$new("devmax", 
             default = 0.999, lower = 0, upper = 1, tags = "train"), ParamDbl$new("eps", 
             default = 1e-06, lower = 0, upper = 1, tags = "train"), ParamDbl$new("big", 
             default = 9.9e+35, tags = "train"), ParamInt$new("mnlam", default = 5, lower = 1L, 
             tags = "train"), ParamDbl$new("pmin", default = 1e-09, lower = 0, upper = 1, 
             tags = "train"), ParamDbl$new("exmx", default = 250, tags = "train"), ParamDbl$new("prec", 
             default = 1e-10, tags = "train"), ParamInt$new("mxit", default = 100L, lower = 1L, 
             tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 2. Error: autotest (@test_classif_kknn.R#4)  --------------------------------
  not a function
  1: mlr3::lrn("classif.kknn") at testthat/test_classif_kknn.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamInt$new("k", default = 7L, lower = 1L, tags = "predict"), 
         ParamDbl$new("distance", default = 2, lower = 0, tags = "predict"), ParamFct$new("kernel", 
             levels = c("rectangular", "triangular", "epanechnikov", "biweight", "triweight", 
                 "cos", "inv", "gaussian", "rank", "optimal"), default = "optimal", tags = "predict"), 
         ParamLgl$new("scale", default = TRUE, tags = "predict")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 3. Error: autotest (@test_classif_lda.R#4)  ---------------------------------
  not a function
  1: mlr3::lrn("classif.lda") at testthat/test_classif_lda.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamFct$new("method", default = "moment", levels = c("moment", 
         "mle", "mve", "t"), tags = "train"), ParamFct$new("predict.method", default = "plug-in", 
         levels = c("plug-in", "predictive", "debiased"), tags = "predict")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 4. Error: autotest (@test_classif_log_reg.R#6)  -----------------------------
  not a function
  1: run_autotest(learner) at testthat/test_classif_log_reg.R:6
  2: learner$clone(deep = TRUE)
  3: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  4: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 5. Error: autotest (@test_classif_naive_bayes.R#4)  -------------------------
  not a function
  1: mlr3::lrn("classif.naive_bayes") at testthat/test_classif_naive_bayes.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamDbl$new("laplace", default = 0, lower = 0, tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 6. Error: autotest (@test_classif_qda.R#4)  ---------------------------------
  not a function
  1: mlr3::lrn("classif.qda") at testthat/test_classif_qda.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamFct$new("method", default = "moment", levels = c("moment", 
         "mle", "mve", "t"), tags = "train"), ParamFct$new("predict.method", default = "plug-in", 
         levels = c("plug-in", "predictive", "debiased", "looCV"), tags = "predict")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 7. Error: autotest (@test_classif_ranger.R#4)  ------------------------------
  not a function
  1: mlr3::lrn("classif.ranger") at testthat/test_classif_ranger.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamInt$new("num.trees", default = 500L, lower = 1L, tags = c("train", 
         "predict")), ParamInt$new("mtry", lower = 1L, tags = "train"), ParamFct$new("importance", 
         levels = c("none", "impurity", "impurity_corrected", "permutation"), tags = "train"), 
         ParamLgl$new("write.forest", default = TRUE, tags = "train"), ParamInt$new("min.node.size", 
             default = 1L, lower = 1L, tags = "train"), ParamLgl$new("replace", default = TRUE, 
             tags = "train"), ParamDbl$new("sample.fraction", lower = 0L, upper = 1L, 
             tags = "train"), ParamFct$new("splitrule", levels = c("gini", "extratrees"), 
             default = "gini", tags = "train"), ParamInt$new("num.random.splits", lower = 1L, 
             default = 1L, tags = "train"), ParamDbl$new("split.select.weights", lower = 0, 
             upper = 1, tags = "train"), ParamUty$new("always.split.variables", tags = "train"), 
         ParamFct$new("respect.unordered.factors", levels = c("ignore", "order", "partition"), 
             default = "ignore", tags = "train"), ParamLgl$new("scale.permutation.importance", 
             default = FALSE, tags = "train"), ParamLgl$new("keep.inbag", default = FALSE, 
             tags = "train"), ParamLgl$new("holdout", default = FALSE, tags = "train"), 
         ParamInt$new("num.threads", lower = 1L, tags = c("train", "predict")), ParamLgl$new("save.memory", 
             default = FALSE, tags = "train"), ParamLgl$new("verbose", default = TRUE, 
             tags = c("train", "predict")), ParamLgl$new("oob.error", default = TRUE, 
             tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 8. Error: autotest (@test_classif_svm.R#4)  ---------------------------------
  not a function
  1: mlr3::lrn("classif.svm") at testthat/test_classif_svm.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamFct$new("type", default = "C-classification", levels = c("C-classification", 
         "nu-classification"), tags = "train"), ParamDbl$new("cost", default = 1, lower = 0, 
         tags = "train"), ParamDbl$new("nu", default = 0.5, tags = "train"), ParamFct$new("kernel", 
         default = "radial", levels = c("linear", "polynomial", "radial", "sigmoid"), 
         tags = "train"), ParamInt$new("degree", default = 3L, lower = 1L, tags = "train"), 
         ParamDbl$new("coef0", default = 0, tags = "train"), ParamDbl$new("gamma", lower = 0, 
             tags = "train"), ParamDbl$new("cachesize", default = 40L, tags = "train"), 
         ParamDbl$new("tolerance", default = 0.001, lower = 0, tags = "train"), ParamLgl$new("shrinking", 
             default = TRUE, tags = "train"), ParamInt$new("cross", default = 0L, lower = 0L, 
             tags = "train"), ParamLgl$new("fitted", default = TRUE, tags = "train"), 
         ParamUty$new("scale", default = TRUE, tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 9. Error: autotest (@test_classif_xgboost.R#4)  -----------------------------
  not a function
  1: mlr3::lrn("classif.xgboost", nrounds = 5L) at testthat/test_classif_xgboost.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamFct$new("booster", default = "gbtree", levels = c("gbtree", 
         "gblinear", "dart"), tags = "train"), ParamUty$new("watchlist", default = NULL, 
         tags = "train"), ParamDbl$new("eta", default = 0.3, lower = 0, upper = 1, tags = "train"), 
         ParamDbl$new("gamma", default = 0, lower = 0, tags = "train"), ParamInt$new("max_depth", 
             default = 6L, lower = 1L, tags = "train"), ParamDbl$new("min_child_weight", 
             default = 1, lower = 0, tags = "train"), ParamDbl$new("subsample", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bytree", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bylevel", 
             default = 1, lower = 0, upper = 1, tags = "train"), ParamInt$new("num_parallel_tree", 
             default = 1L, lower = 1L, tags = "train"), ParamDbl$new("lambda", default = 1, 
             lower = 0, tags = "train"), ParamDbl$new("lambda_bias", default = 0, lower = 0, 
             tags = "train"), ParamDbl$new("alpha", default = 0, lower = 0, tags = "train"), 
         ParamUty$new("objective", default = "binary:logistic", tags = c("train", "predict")), 
         ParamUty$new("eval_metric", default = "error", tags = "train"), ParamDbl$new("base_score", 
             default = 0.5, tags = "train"), ParamDbl$new("max_delta_step", lower = 0, 
             default = 0, tags = "train"), ParamDbl$new("missing", default = NA, tags = c("train", 
             "predict"), special_vals = list(NA, NA_real_, NULL)), ParamInt$new("monotone_constraints", 
             default = 0L, lower = -1L, upper = 1L, tags = "train"), ParamDbl$new("tweedie_variance_power", 
             lower = 1, upper = 2, default = 1.5, tags = "train"), ParamInt$new("nthread", 
             lower = 1L, tags = "train"), ParamInt$new("nrounds", lower = 1L, tags = "train"), 
         ParamUty$new("feval", default = NULL, tags = "train"), ParamInt$new("verbose", 
             default = 1L, lower = 0L, upper = 2L, tags = "train"), ParamInt$new("print_every_n", 
             default = 1L, lower = 1L, tags = "train"), ParamInt$new("early_stopping_rounds", 
             default = NULL, lower = 1L, special_vals = list(NULL), tags = "train"), ParamLgl$new("maximize", 
             default = NULL, special_vals = list(NULL), tags = "train"), ParamFct$new("sample_type", 
             default = "uniform", levels = c("uniform", "weighted"), tags = "train"), 
         ParamFct$new("normalize_type", default = "tree", levels = c("tree", "forest"), 
             tags = "train"), ParamDbl$new("rate_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamDbl$new("skip_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamUty$new("callbacks", default = list(), tags = "train")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 10. Error: xgboost with softmax (@test_classif_xgboost.R#11)  ---------------
  not a function
  1: mlr3::lrn("classif.xgboost", nrounds = 5L, objective = "multi:softmax") at testthat/test_classif_xgboost.R:11
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamFct$new("booster", default = "gbtree", levels = c("gbtree", 
         "gblinear", "dart"), tags = "train"), ParamUty$new("watchlist", default = NULL, 
         tags = "train"), ParamDbl$new("eta", default = 0.3, lower = 0, upper = 1, tags = "train"), 
         ParamDbl$new("gamma", default = 0, lower = 0, tags = "train"), ParamInt$new("max_depth", 
             default = 6L, lower = 1L, tags = "train"), ParamDbl$new("min_child_weight", 
             default = 1, lower = 0, tags = "train"), ParamDbl$new("subsample", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bytree", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bylevel", 
             default = 1, lower = 0, upper = 1, tags = "train"), ParamInt$new("num_parallel_tree", 
             default = 1L, lower = 1L, tags = "train"), ParamDbl$new("lambda", default = 1, 
             lower = 0, tags = "train"), ParamDbl$new("lambda_bias", default = 0, lower = 0, 
             tags = "train"), ParamDbl$new("alpha", default = 0, lower = 0, tags = "train"), 
         ParamUty$new("objective", default = "binary:logistic", tags = c("train", "predict")), 
         ParamUty$new("eval_metric", default = "error", tags = "train"), ParamDbl$new("base_score", 
             default = 0.5, tags = "train"), ParamDbl$new("max_delta_step", lower = 0, 
             default = 0, tags = "train"), ParamDbl$new("missing", default = NA, tags = c("train", 
             "predict"), special_vals = list(NA, NA_real_, NULL)), ParamInt$new("monotone_constraints", 
             default = 0L, lower = -1L, upper = 1L, tags = "train"), ParamDbl$new("tweedie_variance_power", 
             lower = 1, upper = 2, default = 1.5, tags = "train"), ParamInt$new("nthread", 
             lower = 1L, tags = "train"), ParamInt$new("nrounds", lower = 1L, tags = "train"), 
         ParamUty$new("feval", default = NULL, tags = "train"), ParamInt$new("verbose", 
             default = 1L, lower = 0L, upper = 2L, tags = "train"), ParamInt$new("print_every_n", 
             default = 1L, lower = 1L, tags = "train"), ParamInt$new("early_stopping_rounds", 
             default = NULL, lower = 1L, special_vals = list(NULL), tags = "train"), ParamLgl$new("maximize", 
             default = NULL, special_vals = list(NULL), tags = "train"), ParamFct$new("sample_type", 
             default = "uniform", levels = c("uniform", "weighted"), tags = "train"), 
         ParamFct$new("normalize_type", default = "tree", levels = c("tree", "forest"), 
             tags = "train"), ParamDbl$new("rate_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamDbl$new("skip_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamUty$new("callbacks", default = list(), tags = "train")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 11. Error: autotest (@test_regr_glmnet.R#4)  --------------------------------
  not a function
  1: mlr3::lrn("regr.glmnet") at testthat/test_regr_glmnet.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamFct$new("family", default = "gaussian", levels = c("gaussian", 
         "poisson"), tags = "train"), ParamDbl$new("alpha", default = 1, lower = 0, upper = 1, 
         tags = "train"), ParamInt$new("nfolds", lower = 3L, default = 10L, tags = "train"), 
         ParamFct$new("type.measure", levels = c("deviance", "class", "auc", "mse", "mae"), 
             default = "deviance", tags = "train"), ParamDbl$new("s", lower = 0, special_vals = list("lambda.1se", 
             "lambda.min"), default = "lambda.1se", tags = "predict"), ParamInt$new("nlambda", 
             default = 100L, lower = 1L, tags = "train"), ParamDbl$new("lambda.min.ratio", 
             lower = 0, upper = 1, tags = "train"), ParamUty$new("lambda", tags = "train"), 
         ParamLgl$new("standardize", default = TRUE, tags = "train"), ParamLgl$new("intercept", 
             default = TRUE, tags = "train"), ParamDbl$new("thresh", default = 1e-07, 
             lower = 0, tags = "train"), ParamInt$new("dfmax", lower = 0L, tags = "train"), 
         ParamInt$new("pmax", lower = 0L, tags = "train"), ParamInt$new("exclude", lower = 1L, 
             tags = "train"), ParamDbl$new("penalty.factor", lower = 0, upper = 1, tags = "train"), 
         ParamUty$new("lower.limits", tags = "train"), ParamUty$new("upper.limits", tags = "train"), 
         ParamInt$new("maxit", default = 100000L, lower = 1L, tags = "train"), ParamFct$new("type.logistic", 
             levels = c("Newton", "modified.Newton"), tags = "train"), ParamFct$new("type.multinomial", 
             levels = c("ungrouped", "grouped"), tags = "train"), ParamDbl$new("fdev", 
             default = 1e-05, lower = 0, upper = 1, tags = "train"), ParamDbl$new("devmax", 
             default = 0.999, lower = 0, upper = 1, tags = "train"), ParamDbl$new("eps", 
             default = 1e-06, lower = 0, upper = 1, tags = "train"), ParamDbl$new("big", 
             default = 9.9e+35, tags = "train"), ParamInt$new("mnlam", default = 5L, lower = 1L, 
             tags = "train"), ParamDbl$new("pmin", default = 1e-09, lower = 0, upper = 1, 
             tags = "train"), ParamDbl$new("exmx", default = 250, tags = "train"), ParamDbl$new("prec", 
             default = 1e-10, tags = "train"), ParamInt$new("mxit", default = 100L, lower = 1L, 
             tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 12. Error: autotest (@test_regr_kknn.R#4)  ----------------------------------
  not a function
  1: mlr3::lrn("regr.kknn") at testthat/test_regr_kknn.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamInt$new("k", default = 7L, lower = 1L, tags = "predict"), 
         ParamDbl$new("distance", default = 2, lower = 0, tags = "predict"), ParamFct$new("kernel", 
             levels = c("rectangular", "triangular", "epanechnikov", "biweight", "triweight", 
                 "cos", "inv", "gaussian", "rank", "optimal"), default = "optimal", tags = "predict"), 
         ParamLgl$new("scale", default = TRUE, tags = "predict")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 13. Error: autotest (@test_regr_km.R#4)  ------------------------------------
  not a function
  1: mlr3::lrn("regr.km", nugget.stability = 1e-08) at testthat/test_regr_km.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamFct$new("covtype", default = "matern5_2", levels = c("gauss", 
         "matern5_2", "matern3_2", "exp", "powexp"), tags = "train"), ParamDbl$new("nugget", 
         tags = "train"), ParamLgl$new("nugget.estim", default = FALSE, tags = "train"), 
         ParamFct$new("type", default = "SK", levels = c("SK", "UK"), tags = "predict"), 
         ParamDbl$new("nugget.stability", default = 0, lower = 0, tags = "train"), ParamDbl$new("jitter", 
             default = 0, lower = 0, tags = "predict")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 14. Error: autotest w/ jitter (@test_regr_km.R#11)  -------------------------
  not a function
  1: mlr3::lrn("regr.km", nugget.stability = 1e-08, jitter = 1e-08) at testthat/test_regr_km.R:11
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamFct$new("covtype", default = "matern5_2", levels = c("gauss", 
         "matern5_2", "matern3_2", "exp", "powexp"), tags = "train"), ParamDbl$new("nugget", 
         tags = "train"), ParamLgl$new("nugget.estim", default = FALSE, tags = "train"), 
         ParamFct$new("type", default = "SK", levels = c("SK", "UK"), tags = "predict"), 
         ParamDbl$new("nugget.stability", default = 0, lower = 0, tags = "train"), ParamDbl$new("jitter", 
             default = 0, lower = 0, tags = "predict")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 15. Error: autotest (@test_regr_lm.R#6)  ------------------------------------
  not a function
  1: run_autotest(learner) at testthat/test_regr_lm.R:6
  2: learner$clone(deep = TRUE)
  3: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  4: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 16. Error: autotest (@test_regr_ranger.R#4)  --------------------------------
  not a function
  1: mlr3::lrn("regr.ranger", num.trees = 100, importance = "impurity") at testthat/test_regr_ranger.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamInt$new("num.trees", default = 500L, lower = 1L, tags = c("train", 
         "predict")), ParamInt$new("mtry", lower = 1L, tags = "train"), ParamFct$new("importance", 
         levels = c("none", "impurity", "impurity_corrected", "permutation"), tags = "train"), 
         ParamLgl$new("write.forest", default = TRUE, tags = "train"), ParamInt$new("min.node.size", 
             default = 5L, lower = 1L, tags = "train"), ParamLgl$new("replace", default = TRUE, 
             tags = "train"), ParamDbl$new("sample.fraction", lower = 0L, upper = 1L, 
             tags = "train"), ParamFct$new("splitrule", levels = c("variance", "extratrees", 
             "maxstat"), default = "variance", tags = "train"), ParamInt$new("num.random.splits", 
             lower = 1L, default = 1L, tags = "train"), ParamDbl$new("split.select.weights", 
             lower = 0, upper = 1, tags = "train"), ParamUty$new("always.split.variables", 
             tags = "train"), ParamFct$new("respect.unordered.factors", levels = c("ignore", 
             "order", "partition"), default = "ignore", tags = "train"), ParamLgl$new("scale.permutation.importance", 
             default = FALSE, tags = "train"), ParamLgl$new("keep.inbag", default = FALSE, 
             tags = "train"), ParamLgl$new("holdout", default = FALSE, tags = "train"), 
         ParamInt$new("num.threads", lower = 1L, tags = c("train", "predict")), ParamLgl$new("save.memory", 
             default = FALSE, tags = "train"), ParamLgl$new("verbose", default = TRUE, 
             tags = c("train", "predict")), ParamLgl$new("oob.error", default = TRUE, 
             tags = "train")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 17. Error: autotest (@test_regr_svm.R#4)  -----------------------------------
  not a function
  1: mlr3::lrn("regr.svm") at testthat/test_regr_svm.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: dictionary_get(dict, .key)
  4: dictionary_initialize_item(key, obj, dots)
  5: do.call(constructor$new, cargs)
  6: (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
     })()
  7: .subset2(public_bind_env, "initialize")(...)
  8: ParamSet$new(list(ParamFct$new("type", default = "eps-regression", levels = c("eps-regression", 
         "nu-regression"), tags = "train"), ParamFct$new("kernel", default = "radial", 
         levels = c("linear", "polynomial", "radial", "sigmoid"), tags = "train"), ParamInt$new("degree", 
         default = 3L, lower = 1L, tags = "train"), ParamDbl$new("coef0", default = 0, 
         tags = "train"), ParamDbl$new("cost", default = 1, lower = 0, tags = "train"), 
         ParamDbl$new("nu", default = 0.5, tags = "train"), ParamDbl$new("gamma", lower = 0, 
             tags = "train"), ParamDbl$new("cachesize", default = 40L, tags = "train"), 
         ParamDbl$new("tolerance", default = 0.001, lower = 0, tags = "train"), ParamDbl$new("epsilon", 
             lower = 0, tags = "train"), ParamLgl$new("shrinking", default = TRUE, tags = "train"), 
         ParamInt$new("cross", default = 0L, lower = 0L, tags = "train"), ParamLgl$new("fitted", 
             default = TRUE, tags = "train"), ParamUty$new("scale", default = TRUE, tags = "train")))
  9: .subset2(public_bind_env, "initialize")(...)
  10: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  11: map(params, function(p) p$clone(deep = TRUE))
  12: lapply(.x, .f, ...)
  13: FUN(X[[i]], ...)
  14: p$clone(deep = TRUE)
  15: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  16: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 18. Error: autotest (@test_regr_xgboost.R#4)  -------------------------------
  not a function
  1: mlr3::lrn("regr.xgboost", nrounds = 5L) at testthat/test_regr_xgboost.R:4
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_r6(dictionary_initialize_item(.key, obj, dots[ii]))
  4: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  5: dictionary_initialize_item(.key, obj, dots[ii])
  6: do.call(constructor$new, cargs)
  7: (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
     })()
  8: .subset2(public_bind_env, "initialize")(...)
  9: ParamSet$new(list(ParamFct$new("booster", default = "gbtree", levels = c("gbtree", 
         "gblinear", "dart"), tags = "train"), ParamUty$new("watchlist", default = NULL, 
         tags = "train"), ParamDbl$new("eta", default = 0.3, lower = 0, upper = 1, tags = "train"), 
         ParamDbl$new("gamma", default = 0, lower = 0, tags = "train"), ParamInt$new("max_depth", 
             default = 6L, lower = 1L, tags = "train"), ParamDbl$new("min_child_weight", 
             default = 1, lower = 0, tags = "train"), ParamDbl$new("subsample", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bytree", default = 1, 
             lower = 0, upper = 1, tags = "train"), ParamDbl$new("colsample_bylevel", 
             default = 1, lower = 0, upper = 1, tags = "train"), ParamInt$new("num_parallel_tree", 
             default = 1L, lower = 1L, tags = "train"), ParamDbl$new("lambda", default = 1, 
             lower = 0, tags = "train"), ParamDbl$new("lambda_bias", default = 0, lower = 0, 
             tags = "train"), ParamDbl$new("alpha", default = 0, lower = 0, tags = "train"), 
         ParamUty$new("objective", default = "reg:linear", tags = c("train", "predict")), 
         ParamUty$new("eval_metric", default = "rmse", tags = "train"), ParamDbl$new("base_score", 
             default = 0.5, tags = "train"), ParamDbl$new("max_delta_step", lower = 0, 
             default = 0, tags = "train"), ParamDbl$new("missing", default = NA, tags = c("train", 
             "predict"), special_vals = list(NA, NA_real_, NULL)), ParamInt$new("monotone_constraints", 
             default = 0L, lower = -1L, upper = 1L, tags = "train"), ParamDbl$new("tweedie_variance_power", 
             lower = 1, upper = 2, default = 1.5, tags = "train"), ParamInt$new("nthread", 
             lower = 1L, tags = "train"), ParamInt$new("nrounds", lower = 1L, tags = "train"), 
         ParamUty$new("feval", default = NULL, tags = "train"), ParamInt$new("verbose", 
             default = 1L, lower = 0L, upper = 2L, tags = "train"), ParamInt$new("print_every_n", 
             default = 1L, lower = 1L, tags = "train"), ParamInt$new("early_stopping_rounds", 
             default = NULL, lower = 1L, special_vals = list(NULL), tags = "train"), ParamLgl$new("maximize", 
             default = NULL, special_vals = list(NULL), tags = "train"), ParamFct$new("sample_type", 
             default = "uniform", levels = c("uniform", "weighted"), tags = "train"), 
         ParamFct$new("normalize_type", default = "tree", levels = c("tree", "forest"), 
             tags = "train"), ParamDbl$new("rate_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamDbl$new("skip_drop", default = 0, lower = 0, upper = 1, 
             tags = "train"), ParamUty$new("callbacks", default = list(), tags = "train")))
  10: .subset2(public_bind_env, "initialize")(...)
  11: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  12: map(params, function(p) p$clone(deep = TRUE))
  13: lapply(.x, .f, ...)
  14: FUN(X[[i]], ...)
  15: p$clone(deep = TRUE)
  16: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  17: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  == testthat results  ===========================================================
  [ OK: 22 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 18 ]
  1. Error: autotest (@test_classif_glmnet.R#4) 
  2. Error: autotest (@test_classif_kknn.R#4) 
  3. Error: autotest (@test_classif_lda.R#4) 
  4. Error: autotest (@test_classif_log_reg.R#6) 
  5. Error: autotest (@test_classif_naive_bayes.R#4) 
  6. Error: autotest (@test_classif_qda.R#4) 
  7. Error: autotest (@test_classif_ranger.R#4) 
  8. Error: autotest (@test_classif_svm.R#4) 
  9. Error: autotest (@test_classif_xgboost.R#4) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted