Running ‘testthat.R’ [57s/60s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > if (requireNamespace("testthat", quietly = TRUE)) {
  +   library(checkmate)
  +   library(testthat)
  +   library(mlr3)
  + 
  +   test_check("mlr3")
  + }
  ── 1. Error: Backends with mixed data_formats (@test_DataBackendCbind.R#77)  ───
  not a function
  1: resample(task, lrn("regr.rpart"), rsmp("holdout")) at testthat/test_DataBackendCbind.R:77
  2: assert_task(as_task(task, clone = TRUE))
  3: assert_class(task, "Task", .var.name = .var.name)
  4: checkClass(x, classes, ordered, null.ok)
  5: as_task(task, clone = TRUE)
  6: as_task.Task(task, clone = TRUE)
  7: x$clone()
  8: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  9: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 2. Error: Backends with mixed data_formats (@test_DataBackendRbind.R#57)  ───
  not a function
  1: resample(task, lrn("regr.rpart"), rsmp("holdout")) at testthat/test_DataBackendRbind.R:57
  2: assert_task(as_task(task, clone = TRUE))
  3: assert_class(task, "Task", .var.name = .var.name)
  4: checkClass(x, classes, ordered, null.ok)
  5: as_task(task, clone = TRUE)
  6: as_task.Task(task, clone = TRUE)
  7: x$clone()
  8: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  9: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 3. Error: clone (@test_Learner.R#9)  ────────────────────────────────────────
  not a function
  1: lrn("classif.rpart") at testthat/test_Learner.R:9
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 4. Error: Learners are called with invoke / small footprint of call (@test_Le
  not a function
  1: lrn("regr.rpart") at testthat/test_Learner.R:22
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 5. Error: Extra data slots of learners are kept / reset (@test_Learner.R#34) 
  not a function
  1: lrn("regr.rpart") at testthat/test_Learner.R:34
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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: task is checked in train() / predict() (@test_Learner.R#46)  ──────
  not a function
  1: lrn("regr.rpart") at testthat/test_Learner.R:46
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 7. Error: learner timings (@test_Learner.R#52)  ─────────────────────────────
  not a function
  1: lrn("regr.rpart") at testthat/test_Learner.R:52
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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: assert_measure (@test_Measure.R#10)  ──────────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_Measure.R:10
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 9. Error: Classification measures (@test_MeasureClassif.R#6)  ───────────────
  not a function
  1: lrn("classif.featureless", predict_type = "prob") at testthat/test_MeasureClassif.R:6
  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("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 10. Error: Regression measures (@test_MeasureRegr.R#6)  ─────────────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_MeasureRegr.R:6
  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(ParamLgl$new("robust", 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)
  
  ── 11. Error: Internally constructed Prediction (@test_PredictionClassif.R#12)  
  not a function
  1: lrn("classif.featureless") at testthat/test_PredictionClassif.R:12
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 12. Error: setting threshold binaryclass (@test_PredictionClassif.R#21)  ────
  not a function
  1: lrn("classif.rpart", predict_type = "prob") at testthat/test_PredictionClassif.R:21
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 13. Error: setting threshold multiclass (@test_PredictionClassif.R#49)  ─────
  not a function
  1: lrn("classif.rpart", predict_type = "prob") at testthat/test_PredictionClassif.R:49
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 14. Error: confusion (@test_PredictionClassif.R#81)  ────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_PredictionClassif.R:81
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 15. Error: c (@test_PredictionClassif.R#94)  ────────────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_PredictionClassif.R:94
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 16. Error: Internally constructed Prediction (@test_PredictionRegr.R#12)  ───
  not a function
  1: lrn("regr.featureless") at testthat/test_PredictionRegr.R:12
  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(ParamLgl$new("robust", 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)
  
  ── 17. Error: c (@test_PredictionRegr.R#22)  ───────────────────────────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_PredictionRegr.R:22
  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(ParamLgl$new("robust", 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: c drops se (#250) (@test_PredictionRegr.R#45)  ───────────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_PredictionRegr.R:45
  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(ParamLgl$new("robust", 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)
  
  ── 19. Error: param_vals (@test_Resampling.R#5)  ───────────────────────────────
  not a function
  1: rsmp("bootstrap", repeats = 100L, ratio = 1) at testthat/test_Resampling.R:5
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 20. Error: hashing (@test_Resampling.R#31)  ─────────────────────────────────
  not a function
  1: rsmp(key) at testthat/test_Resampling.R:31
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 21. Error: Factor levels are preserved in prediction (@test_TaskClassif.R#25)
  not a function
  1: lrn("classif.featureless") at testthat/test_TaskClassif.R:25
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 22. Error: 0 feature task (@test_TaskClassif.R#58)  ─────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_TaskClassif.R:58
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 23. Error: Positive class always comes first (@test_TaskClassif.R#66)  ──────
  not a function
  1: lrn("classif.featureless", predict_type = "prob", method = "sample") at testthat/test_TaskClassif.R:66
  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("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 24. Error: TaskRegr: 0 feature task (@test_TaskRegr.R#31)  ──────────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_TaskRegr.R:31
  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(ParamLgl$new("robust", 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)
  
  ── 25. Error: (unknown) (@test_benchmark.R#4)  ─────────────────────────────────
  not a function
  1: mlr_learners$mget(c("classif.featureless", "classif.rpart")) at testthat/test_benchmark.R:4
  2: set_names(lapply(keys, self$get, ...), keys)
  3: lapply(keys, self$get, ...)
  4: FUN(X[[i]], ...)
  5: dictionary_get(self, key, ...)
  6: dictionary_initialize_item(key, obj, dots)
  7: do.call(constructor$new, cargs)
  8: (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
     })()
  9: .subset2(public_bind_env, "initialize")(...)
  10: ParamSet$new(list(ParamFct$new("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", tags = "predict")))
  11: .subset2(public_bind_env, "initialize")(...)
  12: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  13: map(params, function(p) p$clone(deep = TRUE))
  14: lapply(.x, .f, ...)
  15: FUN(X[[i]], ...)
  16: p$clone(deep = TRUE)
  17: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  18: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 26. Error: (unknown) (@test_encapsulate.R#14)  ──────────────────────────────
  not a function
  1: lrn("classif.debug") at testthat/test_encapsulate.R:14
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 27. Error: no encapsulation (@test_errorhandling.R#5)  ──────────────────────
  not a function
  1: lrn("classif.debug") at testthat/test_errorhandling.R:5
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 28. Error: no encapsulation / resampling (@test_errorhandling.R#16)  ────────
  not a function
  1: lrn("classif.debug", error_train = 1) at testthat/test_errorhandling.R:16
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 29. Error: encapsulation (@test_errorhandling.R#23)  ────────────────────────
  not a function
  1: lrn("classif.debug") at testthat/test_errorhandling.R:23
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 30. Error: encapsulation / resample (@test_errorhandling.R#60)  ─────────────
  not a function
  1: lrn("classif.debug") at testthat/test_errorhandling.R:60
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 31. Error: encapsulation / benchmark (@test_errorhandling.R#79)  ────────────
  not a function
  1: lrn("classif.debug") at testthat/test_errorhandling.R:79
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 32. Error: train fails gracefully (@test_fallback.R#5)  ─────────────────────
  not a function
  1: lrn("classif.debug", error_train = 1) at testthat/test_fallback.R:5
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 33. Error: predict fails gracefully (@test_fallback.R#11)  ──────────────────
  not a function
  1: lrn("classif.debug", error_predict = 1) at testthat/test_fallback.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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 34. Error: fail during train (@test_fallback.R#18)  ─────────────────────────
  not a function
  1: lrn("classif.debug", error_train = 1) at testthat/test_fallback.R:18
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 35. Error: fail during predict (@test_fallback.R#32)  ───────────────────────
  not a function
  1: lrn("classif.debug", error_predict = 1) at testthat/test_fallback.R:32
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 36. Error: fail during resample (@test_fallback.R#46)  ──────────────────────
  not a function
  1: lrn("classif.debug", error_predict = 1) at testthat/test_fallback.R:46
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 37. Error: incomplete predictions (@test_fallback.R#57)  ────────────────────
  not a function
  1: lrn("classif.debug", predict_type = "prob", predict_missing = 0.5, fallback = lrn("classif.featureless")) at testthat/test_fallback.R:57
  2: dictionary_sugar(mlr_learners, .key, ...)
  3: assert_list(list(...), .var.name = "additional arguments passed to Dictionary")
  4: checkList(x, types, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok)
  5: .Call(c_check_list, x, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok) %and% checkListTypes(x, types)
  6: isTRUE(lhs)
  7: lrn("classif.featureless")
  8: dictionary_sugar(mlr_learners, .key, ...)
  9: dictionary_get(dict, .key)
  10: dictionary_initialize_item(key, obj, dots)
  ...
  13: .subset2(public_bind_env, "initialize")(...)
  14: ParamSet$new(list(ParamFct$new("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", tags = "predict")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 38. Error: learner$hash (@test_hashes.R#21)  ────────────────────────────────
  not a function
  1: lrn("classif.rpart") at testthat/test_hashes.R:21
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 39. Error: resampling$hash (@test_hashes.R#31)  ─────────────────────────────
  not a function
  1: rsmp("cv") at testthat/test_hashes.R:31
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("folds", 
         lower = 1L, tags = "required")))
  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)
  
  ── 40. Error: mlr_learners (@test_mlr_learners.R#4)  ───────────────────────────
  not a function
  1: expect_dictionary(mlr_learners, min_items = 1L) at testthat/test_mlr_learners.R:4
  2: expect_data_table(data.table::as.data.table(d), key = "key", nrows = length(keys))
  3: checkDataTable(x, key, index, types, any.missing, all.missing, min.rows, max.rows, 
         min.cols, max.cols, nrows, ncols, row.names, col.names, null.ok)
  4: data.table::as.data.table(d)
  5: as.data.table.DictionaryLearner(d)
  6: setkeyv(map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, feature_types = list(l$feature_types), packages = list(l$packages), 
             properties = list(l$properties), predict_types = list(l$predict_types))
     }), "key")
  7: is.data.table(x)
  8: map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, feature_types = list(l$feature_types), packages = list(l$packages), 
             properties = list(l$properties), predict_types = list(l$predict_types))
     })
  9: rbindlist(unname(map(.x, .f, ...)), use.names = TRUE, fill = .fill)
  10: unname(map(.x, .f, ...))
  ...
  24: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  25: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  26: .subset2(public_bind_env, "initialize")(...)
  27: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  28: map(params, function(p) p$clone(deep = TRUE))
  29: lapply(.x, .f, ...)
  30: FUN(X[[i]], ...)
  31: p$clone(deep = TRUE)
  32: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  33: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 41. Error: mlr_learners: sugar (@test_mlr_learners.R#20)  ───────────────────
  not a function
  1: lrn("classif.rpart", id = "foo", cp = 0.001, predict_type = "prob") at testthat/test_mlr_learners.R:20
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 42. Error: Simple training/predict (@test_mlr_learners_classif_debug.R#5)  ──
  not a function
  1: lrn("classif.debug") at testthat/test_mlr_learners_classif_debug.R:5
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  9: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  10: assert_param_set(param_set)
  11: assert_r6(param_set, "ParamSet")
  12: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  13: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  14: .subset2(public_bind_env, "initialize")(...)
  15: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  16: map(params, function(p) p$clone(deep = TRUE))
  17: lapply(.x, .f, ...)
  18: FUN(X[[i]], ...)
  19: p$clone(deep = TRUE)
  20: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  21: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 43. Error: updating model works (@test_mlr_learners_classif_debug.R#16)  ────
  not a function
  1: lrn("classif.debug", save_tasks = TRUE) at testthat/test_mlr_learners_classif_debug.R:16
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 44. Error: updating model works / resample (@test_mlr_learners_classif_debug.
  not a function
  1: lrn("classif.debug", save_tasks = TRUE) at testthat/test_mlr_learners_classif_debug.R:29
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 45. Error: NA predictions (@test_mlr_learners_classif_debug.R#37)  ──────────
  not a function
  1: lrn("classif.debug", predict_missing = 0.5, predict_type = "response") at testthat/test_mlr_learners_classif_debug.R:37
  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: super$initialize(id = "classif.debug", feature_types = c("logical", "integer", "numeric", 
         "character", "factor", "ordered"), predict_types = c("response", "prob"), param_set = ParamSet$new(params = list(ParamDbl$new("message_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("message_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("warning_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("warning_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("error_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("error_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("segfault_train", 
         lower = 0, upper = 1, default = 0, tags = "train"), ParamDbl$new("segfault_predict", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamDbl$new("predict_missing", 
         lower = 0, upper = 1, default = 0, tags = "predict"), ParamLgl$new("save_tasks", 
         default = FALSE, tags = c("train", "predict")), ParamDbl$new("x", lower = 0, 
         upper = 1, tags = "train"))), properties = c("twoclass", "multiclass", "missings"))
  10: super$initialize(id = id, task_type = "classif", param_set = param_set, predict_types = predict_types, 
         feature_types = feature_types, properties = properties, data_formats = data_formats, 
         packages = packages)
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(params = list(ParamDbl$new("message_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("message_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("warning_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("warning_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("error_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("error_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("segfault_train", lower = 0, upper = 1, default = 0, 
         tags = "train"), ParamDbl$new("segfault_predict", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamDbl$new("predict_missing", lower = 0, upper = 1, default = 0, 
         tags = "predict"), ParamLgl$new("save_tasks", default = FALSE, tags = c("train", 
         "predict")), ParamDbl$new("x", lower = 0, upper = 1, tags = "train")))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 46. Error: autotest (@test_mlr_learners_classif_featureless.R#4)  ───────────
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_learners_classif_featureless.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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 47. Error: Simple training/predict (@test_mlr_learners_classif_featureless.R#
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_learners_classif_featureless.R:12
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 48. Error: Predict with prob (@test_mlr_learners_classif_featureless.R#27)  ─
  not a function
  1: mlr_learners$get("classif.featureless") at testthat/test_mlr_learners_classif_featureless.R:27
  2: dictionary_get(self, key, ...)
  3: dictionary_initialize_item(key, obj, dots)
  4: do.call(constructor$new, cargs)
  5: (function (...) 
     {
         inherit <- get_inherit()
         if (!is.null(inherit)) {
             if (!inherits(inherit, "R6ClassGenerator")) 
                 stop("`inherit` must be a R6ClassGenerator.")
             if (!identical(portable, inherit$portable)) 
                 stop("Sub and superclass must both be portable or non-portable.")
             recursive_merge <- function(obj, which) {
                 if (is.null(obj)) 
                     return(NULL)
                 merge_vectors(recursive_merge(obj$get_inherit(), which), obj[[which]])
             }
             public_fields <- merge_vectors(recursive_merge(inherit, "public_fields"), 
                 public_fields)
             private_fields <- merge_vectors(recursive_merge(inherit, "private_fields"), 
                 private_fields)
         }
         if (class) {
             classes <- c(classname, get_superclassnames(inherit), "R6")
         }
         else {
             classes <- NULL
         }
         has_priv <- has_private()
         if (portable) {
             if (has_priv) 
                 private_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             else private_bind_env <- NULL
             public_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             enclos_env <- new.env(parent = parent_env, hash = FALSE)
         }
         else {
             if (has_priv) {
                 private_bind_env <- new.env(parent = parent_env, hash = FALSE)
                 public_bind_env <- new.env(parent = private_bind_env, hash = FALSE)
             }
             else {
                 private_bind_env <- NULL
                 public_bind_env <- new.env(parent = parent_env, hash = FALSE)
             }
             enclos_env <- public_bind_env
         }
         enclos_env$self <- public_bind_env
         if (has_priv) 
             enclos_env$private <- private_bind_env
         public_methods <- assign_func_envs(public_methods, enclos_env)
         if (has_priv) 
             private_methods <- assign_func_envs(private_methods, enclos_env)
         if (!is.null(active)) 
             active <- assign_func_envs(active, enclos_env)
         if (length(debug_names) > 0) {
             lapply(public_methods[names(public_methods) %in% debug_names], base::debug)
             lapply(private_methods[names(private_methods) %in% debug_names], base::debug)
             lapply(active[names(active) %in% debug_names], base::debug)
         }
         if (!is.null(inherit)) {
             if (portable) {
                 super_struct <- create_super_env(inherit, public_bind_env, private_bind_env, 
                     portable = TRUE)
             }
             else {
                 super_struct <- create_super_env(inherit, public_bind_env, portable = FALSE)
             }
             enclos_env$super <- super_struct$bind_env
             public_methods <- merge_vectors(super_struct$public_methods, public_methods)
             private_methods <- merge_vectors(super_struct$private_methods, private_methods)
             active <- merge_vectors(super_struct$active, active)
         }
         list2env2(public_methods, envir = public_bind_env)
         list2env2(public_fields, envir = public_bind_env)
         if (has_priv) {
             list2env2(private_methods, envir = private_bind_env)
             list2env2(private_fields, envir = private_bind_env)
         }
         if (!is.null(active)) {
             for (name in names(active)) {
                 makeActiveBinding(name, active[[name]], public_bind_env)
             }
         }
         public_bind_env$.__enclos_env__ <- enclos_env
         if (lock_objects) {
             if (has_priv) 
                 lockEnvironment(private_bind_env)
             lockEnvironment(public_bind_env)
         }
         if (has_priv) {
             for (name in names(private_methods)) lockBinding(name, private_bind_env)
         }
         for (name in names(public_methods)) lockBinding(name, public_bind_env)
         class(public_bind_env) <- classes
         if (is.function(.subset2(public_bind_env, "initialize"))) {
             .subset2(public_bind_env, "initialize")(...)
         }
         else if (length(list(...)) != 0) {
             stop("Called new() with arguments, but there is no initialize method.")
         }
         if (is.function(.subset2(public_bind_env, "finalize"))) {
             finalizer_wrapper <- function(e) {
                 .subset2(e, "finalize")()
             }
             environment(finalizer_wrapper) <- baseenv()
             reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
         }
         if (has_priv) {
             if (is.function(.subset2(private_bind_env, "finalize"))) {
                 finalizer_wrapper <- function(e) {
                     .subset2(e, ".__enclos_env__")$private$finalize()
                 }
                 environment(finalizer_wrapper) <- baseenv()
                 reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
             }
         }
         public_bind_env
     })()
  6: .subset2(public_bind_env, "initialize")(...)
  7: ParamSet$new(list(ParamFct$new("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", tags = "predict")))
  8: .subset2(public_bind_env, "initialize")(...)
  9: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  10: map(params, function(p) p$clone(deep = TRUE))
  11: lapply(.x, .f, ...)
  12: FUN(X[[i]], ...)
  13: p$clone(deep = TRUE)
  14: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  15: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 49. Error: autotest (@test_mlr_learners_classif_rpart.R#4)  ─────────────────
  not a function
  1: lrn("classif.rpart") at testthat/test_mlr_learners_classif_rpart.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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 50. Error: variable importance (@test_mlr_learners_classif_rpart.R#12)  ─────
  not a function
  1: lrn("classif.rpart") at testthat/test_mlr_learners_classif_rpart.R:12
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 51. Error: selected_features (@test_mlr_learners_classif_rpart.R#22)  ───────
  not a function
  1: lrn("classif.rpart", maxdepth = 2) at testthat/test_mlr_learners_classif_rpart.R:22
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 52. Error: autotest (@test_mlr_learners_regr_featureless.R#4)  ──────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_mlr_learners_regr_featureless.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(ParamLgl$new("robust", 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)
  
  ── 53. Error: autotest (@test_mlr_learners_regr_rpart.R#4)  ────────────────────
  not a function
  1: lrn("regr.rpart") at testthat/test_mlr_learners_regr_rpart.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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 54. Error: variable importance (@test_mlr_learners_regr_rpart.R#12)  ────────
  not a function
  1: lrn("regr.rpart") at testthat/test_mlr_learners_regr_rpart.R:12
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 55. Error: selected_features (@test_mlr_learners_regr_rpart.R#22)  ──────────
  not a function
  1: lrn("regr.rpart", maxdepth = 2) at testthat/test_mlr_learners_regr_rpart.R:22
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 56. Error: custom aggregation (@test_mlr_measures.R#26)  ────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_measures.R:26
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 57. Error: mlr_measures_auc (@test_mlr_measures_classif_auc.R#3)  ───────────
  not a function
  1: lrn("classif.featureless", predict_type = "prob") at testthat/test_mlr_measures_classif_auc.R:3
  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("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 58. Error: binary task (@test_mlr_measures_classif_costs.R#17)  ─────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_measures_classif_costs.R:17
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 59. Error: multiclass (@test_mlr_measures_classif_costs.R#31)  ──────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_measures_classif_costs.R:31
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 60. Error: multiclass / level reordering (@test_mlr_measures_classif_costs.R#
  not a function
  1: lrn("classif.featureless") at testthat/test_mlr_measures_classif_costs.R:48
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 61. Error: precision +  recall (@test_mlr_measures_confusion.R#5)  ──────────
  not a function
  1: lrn("classif.featureless", method = "sample") at testthat/test_mlr_measures_confusion.R:5
  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("method", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 62. Error: selected_features (@test_mlr_measures_selected_features.R#5)  ────
  not a function
  1: lrn("classif.rpart") at testthat/test_mlr_measures_selected_features.R:5
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 63. Error: bootstrap has duplicated ids (@test_mlr_resampling_bootstrap.R#4) 
  not a function
  1: rsmp("bootstrap") at testthat/test_mlr_resampling_bootstrap.R:4
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 64. Error: stratification (@test_mlr_resampling_bootstrap.R#13)  ────────────
  not a function
  1: rsmp("bootstrap", ratio = 1, repeats = 3, stratify = TRUE) at testthat/test_mlr_resampling_bootstrap.R:13
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 65. Error: grouping (@test_mlr_resampling_bootstrap.R#23)  ──────────────────
  not a function
  1: rsmp("bootstrap", ratio = 1, repeats = 3) at testthat/test_mlr_resampling_bootstrap.R:23
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 66. Error: cv has no duplicated ids (@test_mlr_resampling_cv.R#4)  ──────────
  not a function
  1: rsmp("cv") at testthat/test_mlr_resampling_cv.R:4
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("folds", 
         lower = 1L, tags = "required")))
  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)
  
  ── 67. Error: stratification (@test_mlr_resampling_cv.R#13)  ───────────────────
  not a function
  1: rsmp("cv", folds = 5L, stratify = TRUE) at testthat/test_mlr_resampling_cv.R:13
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("folds", 
         lower = 1L, tags = "required")))
  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)
  
  ── 68. Error: grouping (@test_mlr_resampling_cv.R#25)  ─────────────────────────
  not a function
  1: rsmp("cv", folds = 3) at testthat/test_mlr_resampling_cv.R:25
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("folds", 
         lower = 1L, tags = "required")))
  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)
  
  ── 69. Error: holdout has no duplicated ids (@test_mlr_resampling_holdout.R#4)  
  not a function
  1: rsmp("holdout") at testthat/test_mlr_resampling_holdout.R:4
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamDbl$new("ratio", 
         lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 70. Error: stratification (@test_mlr_resampling_holdout.R#13)  ──────────────
  not a function
  1: rsmp("holdout", ratio = 0.5, stratify = TRUE) at testthat/test_mlr_resampling_holdout.R:13
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamDbl$new("ratio", 
         lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 71. Error: grouping (@test_mlr_resampling_holdout.R#25)  ────────────────────
  not a function
  1: rsmp("holdout") at testthat/test_mlr_resampling_holdout.R:25
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamDbl$new("ratio", 
         lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 72. Error: repeated cv has no duplicated ids (@test_mlr_resampling_repeated_c
  not a function
  1: rsmp("repeated_cv") at testthat/test_mlr_resampling_repeated_cv.R:4
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1), ParamInt$new("folds", lower = 1L, tags = "required")))
  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)
  
  ── 73. Error: folds first, then repetitions (@test_mlr_resampling_repeated_cv.R#
  not a function
  1: rsmp("repeated_cv", repeats = 2, folds = 3) at testthat/test_mlr_resampling_repeated_cv.R:10
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1), ParamInt$new("folds", lower = 1L, tags = "required")))
  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)
  
  ── 74. Error: stratification (@test_mlr_resampling_repeated_cv.R#23)  ──────────
  not a function
  1: rsmp("repeated_cv", folds = 5, repeats = 2, stratify = TRUE) at testthat/test_mlr_resampling_repeated_cv.R:23
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1), ParamInt$new("folds", lower = 1L, tags = "required")))
  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)
  
  ── 75. Error: grouping (@test_mlr_resampling_repeated_cv.R#35)  ────────────────
  not a function
  1: rsmp("repeated_cv", folds = 5, repeats = 2) at testthat/test_mlr_resampling_repeated_cv.R:35
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1), ParamInt$new("folds", lower = 1L, tags = "required")))
  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)
  
  ── 76. Error: subsampling has no duplicated ids (@test_mlr_resampling_subsamplin
  not a function
  1: rsmp("subsampling") at testthat/test_mlr_resampling_subsampling.R:4
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 77. Error: stratification (@test_mlr_resampling_subsampling.R#13)  ──────────
  not a function
  1: rsmp("subsampling", ratio = 0.5, repeats = 3, stratify = TRUE) at testthat/test_mlr_resampling_subsampling.R:13
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 78. Error: grouping (@test_mlr_resampling_subsampling.R#25)  ────────────────
  not a function
  1: rsmp("subsampling", ratio = 0.5, repeats = 3) at testthat/test_mlr_resampling_subsampling.R:25
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 79. Error: mlr_resamplings (@test_mlr_resamplings.R#4)  ─────────────────────
  not a function
  1: expect_dictionary(mlr_resamplings, min_items = 1L) at testthat/test_mlr_resamplings.R:4
  2: expect_data_table(data.table::as.data.table(d), key = "key", nrows = length(keys))
  3: checkDataTable(x, key, index, types, any.missing, all.missing, min.rows, max.rows, 
         min.cols, max.cols, nrows, ncols, row.names, col.names, null.ok)
  4: data.table::as.data.table(d)
  5: as.data.table.DictionaryResampling(d)
  6: setkeyv(map_dtr(x$keys(), function(key) {
         r = x$get(key)
         list(key = key, params = list(r$param_set$ids()), iters = r$iters)
     }), "key")
  7: is.data.table(x)
  8: map_dtr(x$keys(), function(key) {
         r = x$get(key)
         list(key = key, params = list(r$param_set$ids()), iters = r$iters)
     })
  9: rbindlist(unname(map(.x, .f, ...)), use.names = TRUE, fill = .fill)
  10: unname(map(.x, .f, ...))
  ...
  19: .subset2(public_bind_env, "initialize")(...)
  20: ParamSet$new(list(ParamUty$new("stratify", default = NULL), ParamInt$new("repeats", 
         lower = 1L, tags = "required"), ParamDbl$new("ratio", lower = 0, upper = 1, tags = "required")))
  21: .subset2(public_bind_env, "initialize")(...)
  22: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  23: map(params, function(p) p$clone(deep = TRUE))
  24: lapply(.x, .f, ...)
  25: FUN(X[[i]], ...)
  26: p$clone(deep = TRUE)
  27: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  28: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 80. Error: mlr_resamplings: sugar (@test_mlr_resamplings.R#24)  ─────────────
  not a function
  1: rsmp("cv", id = "cv3", folds = 3L) at testthat/test_mlr_resamplings.R:24
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamInt$new("folds", 
         lower = 1L, tags = "required")))
  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)
  
  ── 81. Error: mlr_task_generators (@test_mlr_task_generators.R#4)  ─────────────
  not a function
  1: expect_dictionary(mlr_task_generators, min_items = 1L, contains = "TaskGenerator") at testthat/test_mlr_task_generators.R:4
  2: checkmate::expect_list(d$mget(keys), types = contains, names = "unique")
  3: checkList(x, types, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok)
  4: .Call(c_check_list, x, any.missing, all.missing, len, min.len, max.len, unique, names, 
         null.ok) %and% checkListTypes(x, types)
  5: isTRUE(lhs)
  6: d$mget(keys)
  7: set_names(lapply(keys, self$get, ...), keys)
  8: lapply(keys, self$get, ...)
  9: FUN(X[[i]], ...)
  10: dictionary_get(self, key, ...)
  ...
  14: .subset2(public_bind_env, "initialize")(...)
  15: ParamSet$new(list(ParamInt$new("cl", lower = 2L), ParamDbl$new("r", lower = 1L), 
         ParamDbl$new("sd", lower = 0L)))
  16: .subset2(public_bind_env, "initialize")(...)
  17: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  18: map(params, function(p) p$clone(deep = TRUE))
  19: lapply(.x, .f, ...)
  20: FUN(X[[i]], ...)
  21: p$clone(deep = TRUE)
  22: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  23: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 82. Error: as.data.table(mlr_task_generators) (@test_mlr_task_generators.R#24
  not a function
  1: as.data.table(mlr_task_generators) at testthat/test_mlr_task_generators.R:24
  2: as.data.table.DictionaryTaskGenerator(mlr_task_generators)
  3: setkeyv(map_dtr(x$keys(), function(key) {
         g = x$get(key)
         list(key = key, packages = list(g$packages))
     }), "key")
  4: is.data.table(x)
  5: map_dtr(x$keys(), function(key) {
         g = x$get(key)
         list(key = key, packages = list(g$packages))
     })
  6: rbindlist(unname(map(.x, .f, ...)), use.names = TRUE, fill = .fill)
  7: unname(map(.x, .f, ...))
  8: map(.x, .f, ...)
  9: lapply(.x, .f, ...)
  10: FUN(X[[i]], ...)
  ...
  16: .subset2(public_bind_env, "initialize")(...)
  17: ParamSet$new(list(ParamInt$new("cl", lower = 2L), ParamDbl$new("r", lower = 1L), 
         ParamDbl$new("sd", lower = 0L)))
  18: .subset2(public_bind_env, "initialize")(...)
  19: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  20: map(params, function(p) p$clone(deep = TRUE))
  21: lapply(.x, .f, ...)
  22: FUN(X[[i]], ...)
  23: p$clone(deep = TRUE)
  24: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  25: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 83. Error: parallel resample (@test_parallel.R#7)  ──────────────────────────
  not a function
  1: with_future(future.callr::callr, {
         expect_true(use_future())
         task = tsk("iris")
         learner = lrn("classif.rpart")
         rr = resample(task, learner, rsmp("cv", folds = 3))
         expect_resample_result(rr)
         expect_data_table(rr$errors, nrows = 0L)
     }) at testthat/test_parallel.R:7
  2: force(expr)
  3: lrn("classif.rpart") at testthat/test_parallel.R:11
  4: dictionary_sugar(mlr_learners, .key, ...)
  5: dictionary_get(dict, .key)
  6: dictionary_initialize_item(key, obj, dots)
  7: do.call(constructor$new, cargs)
  8: (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
     })()
  9: .subset2(public_bind_env, "initialize")(...)
  10: ParamSet$new(list(ParamInt$new(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, tags = "train")))
  11: .subset2(public_bind_env, "initialize")(...)
  12: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  13: map(params, function(p) p$clone(deep = TRUE))
  14: lapply(.x, .f, ...)
  15: FUN(X[[i]], ...)
  16: p$clone(deep = TRUE)
  17: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  18: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 84. Error: parallel benchmark (@test_parallel.R#23)  ────────────────────────
  not a function
  1: with_future(future.callr::callr, {
         expect_true(use_future())
         task = tsk("iris")
         learner = lrn("classif.rpart")
         bmr = benchmark(benchmark_grid(task, learner, rsmp("cv", folds = 3)))
         expect_benchmark_result(bmr)
         expect_equal(bmr$aggregate(conditions = TRUE)$warnings, 0L)
         expect_equal(bmr$aggregate(conditions = TRUE)$errors, 0L)
     }) at testthat/test_parallel.R:23
  2: force(expr)
  3: lrn("classif.rpart") at testthat/test_parallel.R:27
  4: dictionary_sugar(mlr_learners, .key, ...)
  5: dictionary_get(dict, .key)
  6: dictionary_initialize_item(key, obj, dots)
  7: do.call(constructor$new, cargs)
  8: (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
     })()
  9: .subset2(public_bind_env, "initialize")(...)
  10: ParamSet$new(list(ParamInt$new(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, tags = "train")))
  11: .subset2(public_bind_env, "initialize")(...)
  12: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  13: map(params, function(p) p$clone(deep = TRUE))
  14: lapply(.x, .f, ...)
  15: FUN(X[[i]], ...)
  16: p$clone(deep = TRUE)
  17: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  18: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  ── 85. Error: predict on newdata works / classif (@test_predict.R#6)  ──────────
  not a function
  1: lrn("classif.featureless") at testthat/test_predict.R:6
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 86. Error: predict on newdata works / regr (@test_predict.R#21)  ────────────
  not a function
  1: lrn("regr.featureless") at testthat/test_predict.R:21
  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(ParamLgl$new("robust", 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)
  
  ── 87. Error: predict on newdata works / no target column (@test_predict.R#37)  
  not a function
  1: lrn("regr.featureless") at testthat/test_predict.R:37
  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(ParamLgl$new("robust", 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)
  
  ── 88. Error: predict on newdata works / titanic use case (@test_predict.R#75)  
  not a function
  1: lrn("classif.rpart") at testthat/test_predict.R:75
  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(id = "minsplit", default = 20L, lower = 1L, tags = "train"), 
         ParamDbl$new(id = "cp", default = 0.01, lower = 0, upper = 1, tags = "train"), 
         ParamInt$new(id = "maxcompete", default = 4L, lower = 0L, tags = "train"), ParamInt$new(id = "maxsurrogate", 
             default = 5L, lower = 0L, tags = "train"), ParamInt$new(id = "maxdepth", 
             default = 30L, lower = 1L, upper = 30L, tags = "train"), ParamInt$new(id = "xval", 
             default = 10L, lower = 0L, 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)
  
  ── 89. Error: predict train + test set (@test_predict.R#91)  ───────────────────
  not a function
  1: rsmp("holdout") at testthat/test_predict.R:91
  2: dictionary_sugar(mlr_resamplings, .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(ParamUty$new("stratify", default = NULL), ParamDbl$new("ratio", 
         lower = 0, upper = 1, tags = "required")))
  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)
  
  ── 90. Error: resample (@test_resample.R#5)  ───────────────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:5
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 91. Error: resample with no or multiple measures (@test_resample.R#24)  ─────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:24
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 92. Error: as_benchmark_result.ResampleResult (@test_resample.R#40)  ────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:40
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 93. Error: discarding model (@test_resample.R#55)  ──────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:55
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 94. Error: inputs are cloned (@test_resample.R#64)  ─────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:64
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 95. Error: memory footprint (@test_resample.R#76)  ──────────────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:76
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ── 96. Error: predict_type is checked (@test_resample.R#88)  ───────────────────
  not a function
  1: lrn("classif.featureless") at testthat/test_resample.R:88
  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", levels = c("mode", "sample", "weighted.sample"), 
         default = "mode", 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)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  [ OK: 1859 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 96 ]
  1. Error: Backends with mixed data_formats (@test_DataBackendCbind.R#77) 
  2. Error: Backends with mixed data_formats (@test_DataBackendRbind.R#57) 
  3. Error: clone (@test_Learner.R#9) 
  4. Error: Learners are called with invoke / small footprint of call (@test_Learner.R#22) 
  5. Error: Extra data slots of learners are kept / reset (@test_Learner.R#34) 
  6. Error: task is checked in train() / predict() (@test_Learner.R#46) 
  7. Error: learner timings (@test_Learner.R#52) 
  8. Error: assert_measure (@test_Measure.R#10) 
  9. Error: Classification measures (@test_MeasureClassif.R#6) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted