CRAN Package Check Results for Package mlr3learners

Last updated on 2019-10-15 13:46:59 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.1.3 13.60 133.48 147.08 OK
r-devel-linux-x86_64-debian-gcc 0.1.3 10.57 27.62 38.19 ERROR
r-devel-linux-x86_64-fedora-clang 0.1.3 124.52 OK
r-devel-linux-x86_64-fedora-gcc 0.1.3 61.91 ERROR
r-devel-windows-ix86+x86_64 0.1.3 17.00 110.00 127.00 OK
r-patched-linux-x86_64 0.1.3 11.77 114.58 126.35 OK
r-patched-solaris-x86 0.1.3 119.40 OK
r-release-linux-x86_64 0.1.3 14.00 113.04 127.04 OK
r-release-windows-ix86+x86_64 0.1.3 24.00 66.00 90.00 OK
r-release-osx-x86_64 0.1.3 OK
r-oldrel-windows-ix86+x86_64 0.1.3 14.00 72.00 86.00 OK
r-oldrel-osx-x86_64 0.1.3 OK

Check Details

Version: 0.1.3
Check: examples
Result: ERROR
    Running examples in ‘mlr3learners-Ex.R’ failed
    The error most likely occurred in:
    
    > base::assign(".ptime", proc.time(), pos = "CheckExEnv")
    > ### Name: LearnerClassifGlmnet
    > ### Title: GLM with Elastic Net Regularization Classification Learner
    > ### Aliases: LearnerClassifGlmnet mlr_learners_classif.glmnet
    > ### Keywords: datasets
    >
    > ### ** Examples
    >
    > learner = mlr3::lrn("classif.glmnet")
    Error in makeActiveBinding(name, active_copies[[name]], new_slice$binding) :
     not a function
    Calls: <Anonymous> ... FUN -> <Anonymous> -> copy_slice -> makeActiveBinding
    Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 0.1.3
Check: tests
Result: ERROR
     Running ‘testthat.R’ [2s/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
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 0.1.3
Check: examples
Result: ERROR
    Running examples in ‘mlr3learners-Ex.R’ failed
    The error most likely occurred in:
    
    > ### Name: LearnerClassifGlmnet
    > ### Title: GLM with Elastic Net Regularization Classification Learner
    > ### Aliases: LearnerClassifGlmnet mlr_learners_classif.glmnet
    > ### Keywords: datasets
    >
    > ### ** Examples
    >
    > learner = mlr3::lrn("classif.glmnet")
    Error in makeActiveBinding(name, active_copies[[name]], new_slice$binding) :
     not a function
    Calls: <Anonymous> ... FUN -> <Anonymous> -> copy_slice -> makeActiveBinding
    Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 0.1.3
Check: tests
Result: ERROR
     Running ‘testthat.R’
    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
Flavor: r-devel-linux-x86_64-fedora-gcc