Running 'testthat.R' [2s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(checkmate)
  > library(mlr3)
  > library(mlr3tuning)
  > 
  > 
  > test_check("mlr3tuning")
  -- 1. Error: AutoTuner / train+predict (@test_AutoTuner.R#4)  ------------------
  not a function
  1: term("evals", n_evals = 3) at testthat/test_AutoTuner.R:4
  2: dictionary_sugar(mlr_terminators, .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("n_evals", lower = 1L, default = 100L, 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)
  
  -- 2. Error: AutoTuner / resample (@test_AutoTuner.R#31)  ----------------------
  not a function
  1: tnr("grid_search", resolution = 3) at testthat/test_AutoTuner.R:31
  2: dictionary_sugar(mlr_tuners, .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("batch_size", lower = 1L, tags = "required"), ParamInt$new("resolution", 
         lower = 1L), ParamUty$new("param_resolutions")))
  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)
  
  -- 3. Error: AutoTuner / param_set (@test_AutoTuner.R#61)  ---------------------
  not a function
  1: term("evals", n_evals = 3) at testthat/test_AutoTuner.R:61
  2: dictionary_sugar(mlr_terminators, .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("n_evals", lower = 1L, default = 100L, 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)
  
  -- 4. Error: Time (@test_TerminatorClockTime.R#4)  -----------------------------
  not a function
  1: term("clock_time", secs = 1) at testthat/test_TerminatorClockTime.R:4
  2: dictionary_sugar(mlr_terminators, .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(ParamDbl$new("secs", lower = 0, default = 100), ParamUty$new("stop_time")))
  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)
  
  -- 5. Error: API (@test_TerminatorCombo.R#4)  ----------------------------------
  not a function
  1: term("evals", n_evals = 2) at testthat/test_TerminatorCombo.R:4
  2: dictionary_sugar(mlr_terminators, .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("n_evals", lower = 1L, default = 100L, 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)
  
  -- 6. Error: API (@test_TerminatorEvals.R#4)  ----------------------------------
  not a function
  1: term("evals", n_evals = 2) at testthat/test_TerminatorEvals.R:4
  2: dictionary_sugar(mlr_terminators, .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("n_evals", lower = 1L, default = 100L, 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)
  
  -- 7. Error: API (@test_TerminatorModelTime.R#4)  ------------------------------
  not a function
  1: term("model_time", secs = 2) at testthat/test_TerminatorModelTime.R:4
  2: dictionary_sugar(mlr_terminators, .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(ParamDbl$new("secs", lower = 0, default = 0, 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)
  
  -- 8. Error: TerminatorPerfReached (@test_TerminatorPerfReached.R#4)  ----------
  not a function
  1: term("perf_reached", level = 0.5) at testthat/test_TerminatorPerfReached.R:4
  2: dictionary_sugar(mlr_terminators, .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(ParamDbl$new("level", default = 0, 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)
  
  -- 9. Error: TerminatorStagnation (@test_TerminatorStagnation.R#4)  ------------
  not a function
  1: term("stagnation", iters = 3) at testthat/test_TerminatorStagnation.R:4
  2: dictionary_sugar(mlr_terminators, .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("iters", lower = 1L, default = 10, tags = "required"), 
         ParamDbl$new("threshold", lower = 0, default = 0, 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)
  
  -- 10. Error: API (@test_Tuner.R#6)  -------------------------------------------
  not a function
  1: TunerRandomSearch$new() at testthat/test_Tuner.R:6
  2: .subset2(public_bind_env, "initialize")(...)
  3: ParamSet$new(list(ParamInt$new("batch_size", lower = 1L, tags = "required")))
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 11. Error: proper error if tuner cannot handle deps (@test_Tuner.R#17)  -----
  not a function
  1: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.001, upper = 0.1), ParamDbl$new("minsplit", 
         lower = 1, upper = 10))) at testthat/test_Tuner.R:17
  2: .subset2(public_bind_env, "initialize")(...)
  3: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  4: map(params, function(p) p$clone(deep = TRUE))
  5: lapply(.x, .f, ...)
  6: FUN(X[[i]], ...)
  7: p$clone(deep = TRUE)
  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)
  
  -- 12. Error: we get a result when some subordinate params are not fulfilled (@t
  not a function
  1: TEST_MAKE_INST2(measures = msr("dummy.cp.regr")) at testthat/test_Tuner.R:29
  2: TEST_MAKE_PS2() at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:122
  3: ParamSet$new(params = list(ParamFct$new("xx", levels = c("a", "b"), default = "a"), 
         ParamDbl$new("yy", lower = 0, upper = 1), ParamDbl$new("cp", lower = 0, upper = 1))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:111
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 13. Error: TunerDesignPoints (@test_TunerDesignPoints.R#5)  -----------------
  not a function
  1: test_tuner("design_points", design = d, term_evals = 2L, real_evals = 2, n_dim = 1L) at testthat/test_TunerDesignPoints.R:5
  2: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:26
  3: .subset2(public_bind_env, "initialize")(...)
  4: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  5: map(params, function(p) p$clone(deep = TRUE))
  6: lapply(.x, .f, ...)
  7: FUN(X[[i]], ...)
  8: p$clone(deep = TRUE)
  9: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  10: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 14. Error: TunerGenSA (@test_TunerGenSA.R#5)  -------------------------------
  not a function
  1: test_tuner("gensa") at testthat/test_TunerGenSA.R:5
  2: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:26
  3: .subset2(public_bind_env, "initialize")(...)
  4: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  5: map(params, function(p) p$clone(deep = TRUE))
  6: lapply(.x, .f, ...)
  7: FUN(X[[i]], ...)
  8: p$clone(deep = TRUE)
  9: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  10: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 15. Error: TunerGenSA with int params and trafo (@test_TunerGenSA.R#17)  ----
  not a function
  1: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.001, upper = 0.1), ParamDbl$new("minsplit", 
         lower = 1, upper = 10))) at testthat/test_TunerGenSA.R:17
  2: .subset2(public_bind_env, "initialize")(...)
  3: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  4: map(params, function(p) p$clone(deep = TRUE))
  5: lapply(.x, .f, ...)
  6: FUN(X[[i]], ...)
  7: p$clone(deep = TRUE)
  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)
  
  -- 16. Error: TunerGridSearch (@test_TunerGridSearch.R#4)  ---------------------
  not a function
  1: test_tuner("grid_search", resolution = 7, term_evals = 5L, real_evals = 5, n_dim = 1L) at testthat/test_TunerGridSearch.R:4
  2: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:26
  3: .subset2(public_bind_env, "initialize")(...)
  4: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  5: map(params, function(p) p$clone(deep = TRUE))
  6: lapply(.x, .f, ...)
  7: FUN(X[[i]], ...)
  8: p$clone(deep = TRUE)
  9: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  10: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 17. Error: TunerGridSearch with TerminatorNone (@test_TunerGridSearch.R#21)  
  not a function
  1: TEST_MAKE_INST1(n_dim = 2L) at testthat/test_TunerGridSearch.R:21
  2: TEST_MAKE_PS1(n_dim = n_dim) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:98
  3: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3), ParamInt$new("minsplit", 
         lower = 1, upper = 9))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:91
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 18. Error: TunerRandomSearch (@test_TunerRandomSearch.R#4)  -----------------
  not a function
  1: test_tuner("random_search") at testthat/test_TunerRandomSearch.R:4
  2: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:26
  3: .subset2(public_bind_env, "initialize")(...)
  4: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  5: map(params, function(p) p$clone(deep = TRUE))
  6: lapply(.x, .f, ...)
  7: FUN(X[[i]], ...)
  8: p$clone(deep = TRUE)
  9: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  10: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 19. Error: TuningInstance (@test_TuningInstance.R#4)  -----------------------
  not a function
  1: TEST_MAKE_INST1(values = list(maxdepth = 10), folds = 2L, measures = msr("dummy.cp.classif"), 
         n_dim = 2) at testthat/test_TuningInstance.R:4
  2: TEST_MAKE_PS1(n_dim = n_dim) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:98
  3: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3), ParamInt$new("minsplit", 
         lower = 1, upper = 9))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:91
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 20. Error: archive one row (#40) (@test_TuningInstance.R#55)  ---------------
  not a function
  1: TEST_MAKE_INST1() at testthat/test_TuningInstance.R:55
  2: TEST_MAKE_PS1(n_dim = n_dim) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:98
  3: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:87
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 21. Error: budget (@test_TuningInstance.R#63)  ------------------------------
  not a function
  1: TEST_MAKE_INST1() at testthat/test_TuningInstance.R:63
  2: TEST_MAKE_PS1(n_dim = n_dim) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:98
  3: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:87
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 22. Error: the same experiment can be added twice (@test_TuningInstance.R#82)
  not a function
  1: TEST_MAKE_INST1() at testthat/test_TuningInstance.R:82
  2: TEST_MAKE_PS1(n_dim = n_dim) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:98
  3: ParamSet$new(params = list(ParamDbl$new("cp", lower = 0.1, upper = 0.3))) at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:87
  4: .subset2(public_bind_env, "initialize")(...)
  5: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  6: map(params, function(p) p$clone(deep = TRUE))
  7: lapply(.x, .f, ...)
  8: FUN(X[[i]], ...)
  9: p$clone(deep = TRUE)
  10: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  11: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 23. Error: failing learner (@test_error_handling.R#4)  ----------------------
  not a function
  1: lrn("classif.debug") at testthat/test_error_handling.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: 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)
  
  -- 24. Error: predictions missing (@test_error_handling.R#29)  -----------------
  not a function
  1: lrn("classif.debug") at testthat/test_error_handling.R:29
  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)
  
  -- 25. Error: faulty measure (@test_error_handling.R#44)  ----------------------
  not a function
  1: lrn("classif.debug") at testthat/test_error_handling.R:44
  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)
  
  -- 26. Error: mlr_terminators sugar (@test_mlr_terminators.R#12)  --------------
  not a function
  1: term("evals", n_evals = 10) at testthat/test_mlr_terminators.R:12
  2: dictionary_sugar(mlr_terminators, .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("n_evals", lower = 1L, default = 100L, 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)
  
  -- 27. Error: mlr_tuners (@test_mlr_tuners.R#6)  -------------------------------
  not a function
  1: expect_tuner(tnr(key)) at testthat/test_mlr_tuners.R:6
  2: expect_r6(tuner, "Tuner", public = c("tune", "param_set"), private = "tune_internal") at d:\RCompile\CRANpkg\local\3.7\mlr3tuning.Rcheck\tests\testthat\helper.R:4
  3: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  4: tnr(key)
  5: dictionary_sugar(mlr_tuners, .key, ...)
  6: dictionary_get(dict, .key)
  7: dictionary_initialize_item(key, obj, dots)
  8: do.call(constructor$new, cargs)
  9: (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
     })()
  10: .subset2(public_bind_env, "initialize")(...)
  11: ParamSet$new(list(ParamInt$new("batch_size", lower = 1L, tags = "required"), ParamUty$new("design", 
         tags = "required")))
  12: .subset2(public_bind_env, "initialize")(...)
  13: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  14: map(params, function(p) p$clone(deep = TRUE))
  15: lapply(.x, .f, ...)
  16: FUN(X[[i]], ...)
  17: p$clone(deep = TRUE)
  18: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  19: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 28. Error: mlr_tuners sugar (@test_mlr_tuners.R#11)  ------------------------
  not a function
  1: tnr("random_search") at testthat/test_mlr_tuners.R:11
  2: dictionary_sugar(mlr_tuners, .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("batch_size", 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)
  
  -- 29. Error: simple exp trafo works (@test_trafos.R#4)  -----------------------
  not a function
  1: lrn("classif.rpart") at testthat/test_trafos.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)
  
  -- 30. Error: trafo where param names change (@test_trafos.R#26)  --------------
  not a function
  1: lrn("classif.rpart") at testthat/test_trafos.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(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)
  
  == testthat results  ===========================================================
  [ OK: 13 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 30 ]
  1. Error: AutoTuner / train+predict (@test_AutoTuner.R#4) 
  2. Error: AutoTuner / resample (@test_AutoTuner.R#31) 
  3. Error: AutoTuner / param_set (@test_AutoTuner.R#61) 
  4. Error: Time (@test_TerminatorClockTime.R#4) 
  5. Error: API (@test_TerminatorCombo.R#4) 
  6. Error: API (@test_TerminatorEvals.R#4) 
  7. Error: API (@test_TerminatorModelTime.R#4) 
  8. Error: TerminatorPerfReached (@test_TerminatorPerfReached.R#4) 
  9. Error: TerminatorStagnation (@test_TerminatorStagnation.R#4) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted