Running 'testthat.R' [1s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(mlr3filters)
  > 
  > test_check("mlr3filters")
  -- 1. Error: FilterImportance (@test_FilterImportance.R#5)  --------------------
  not a function
  1: mlr3::mlr_learners$get("classif.rpart") at testthat/test_FilterImportance.R:5
  2: dictionary_get(self, key, ...)
  3: dictionary_initialize_item(key, obj, dots)
  4: do.call(constructor$new, cargs)
  5: (function (...) 
     {
         inherit <- get_inherit()
         if (!is.null(inherit)) {
             if (!inherits(inherit, "R6ClassGenerator")) 
                 stop("`inherit` must be a R6ClassGenerator.")
             if (!identical(portable, inherit$portable)) 
                 stop("Sub and superclass must both be portable or non-portable.")
             recursive_merge <- function(obj, which) {
                 if (is.null(obj)) 
                     return(NULL)
                 merge_vectors(recursive_merge(obj$get_inherit(), which), obj[[which]])
             }
             public_fields <- merge_vectors(recursive_merge(inherit, "public_fields"), 
                 public_fields)
             private_fields <- merge_vectors(recursive_merge(inherit, "private_fields"), 
                 private_fields)
         }
         if (class) {
             classes <- c(classname, get_superclassnames(inherit), "R6")
         }
         else {
             classes <- NULL
         }
         has_priv <- has_private()
         if (portable) {
             if (has_priv) 
                 private_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             else private_bind_env <- NULL
             public_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             enclos_env <- new.env(parent = parent_env, hash = FALSE)
         }
         else {
             if (has_priv) {
                 private_bind_env <- new.env(parent = parent_env, hash = FALSE)
                 public_bind_env <- new.env(parent = private_bind_env, hash = FALSE)
             }
             else {
                 private_bind_env <- NULL
                 public_bind_env <- new.env(parent = parent_env, hash = FALSE)
             }
             enclos_env <- public_bind_env
         }
         enclos_env$self <- public_bind_env
         if (has_priv) 
             enclos_env$private <- private_bind_env
         public_methods <- assign_func_envs(public_methods, enclos_env)
         if (has_priv) 
             private_methods <- assign_func_envs(private_methods, enclos_env)
         if (!is.null(active)) 
             active <- assign_func_envs(active, enclos_env)
         if (length(debug_names) > 0) {
             lapply(public_methods[names(public_methods) %in% debug_names], base::debug)
             lapply(private_methods[names(private_methods) %in% debug_names], base::debug)
             lapply(active[names(active) %in% debug_names], base::debug)
         }
         if (!is.null(inherit)) {
             if (portable) {
                 super_struct <- create_super_env(inherit, public_bind_env, private_bind_env, 
                     portable = TRUE)
             }
             else {
                 super_struct <- create_super_env(inherit, public_bind_env, portable = FALSE)
             }
             enclos_env$super <- super_struct$bind_env
             public_methods <- merge_vectors(super_struct$public_methods, public_methods)
             private_methods <- merge_vectors(super_struct$private_methods, private_methods)
             active <- merge_vectors(super_struct$active, active)
         }
         list2env2(public_methods, envir = public_bind_env)
         list2env2(public_fields, envir = public_bind_env)
         if (has_priv) {
             list2env2(private_methods, envir = private_bind_env)
             list2env2(private_fields, envir = private_bind_env)
         }
         if (!is.null(active)) {
             for (name in names(active)) {
                 makeActiveBinding(name, active[[name]], public_bind_env)
             }
         }
         public_bind_env$.__enclos_env__ <- enclos_env
         if (lock_objects) {
             if (has_priv) 
                 lockEnvironment(private_bind_env)
             lockEnvironment(public_bind_env)
         }
         if (has_priv) {
             for (name in names(private_methods)) lockBinding(name, private_bind_env)
         }
         for (name in names(public_methods)) lockBinding(name, public_bind_env)
         class(public_bind_env) <- classes
         if (is.function(.subset2(public_bind_env, "initialize"))) {
             .subset2(public_bind_env, "initialize")(...)
         }
         else if (length(list(...)) != 0) {
             stop("Called new() with arguments, but there is no initialize method.")
         }
         if (is.function(.subset2(public_bind_env, "finalize"))) {
             finalizer_wrapper <- function(e) {
                 .subset2(e, "finalize")()
             }
             environment(finalizer_wrapper) <- baseenv()
             reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
         }
         if (has_priv) {
             if (is.function(.subset2(private_bind_env, "finalize"))) {
                 finalizer_wrapper <- function(e) {
                     .subset2(e, ".__enclos_env__")$private$finalize()
                 }
                 environment(finalizer_wrapper) <- baseenv()
                 reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
             }
         }
         public_bind_env
     })()
  6: .subset2(public_bind_env, "initialize")(...)
  7: ParamSet$new(list(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")))
  8: .subset2(public_bind_env, "initialize")(...)
  9: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  10: map(params, function(p) p$clone(deep = TRUE))
  11: lapply(.x, .f, ...)
  12: FUN(X[[i]], ...)
  13: p$clone(deep = TRUE)
  14: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  15: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 2. Error: Filtering an empty Task (#39) (@test_filter.R#5)  -----------------
  not a function
  1: mlr_filters$get("variance") at testthat/test_filter.R:5
  2: dictionary_get(self, key, ...)
  3: dictionary_initialize_item(key, obj, dots)
  4: do.call(constructor$new, cargs)
  5: (function (...) 
     {
         inherit <- get_inherit()
         if (!is.null(inherit)) {
             if (!inherits(inherit, "R6ClassGenerator")) 
                 stop("`inherit` must be a R6ClassGenerator.")
             if (!identical(portable, inherit$portable)) 
                 stop("Sub and superclass must both be portable or non-portable.")
             recursive_merge <- function(obj, which) {
                 if (is.null(obj)) 
                     return(NULL)
                 merge_vectors(recursive_merge(obj$get_inherit(), which), obj[[which]])
             }
             public_fields <- merge_vectors(recursive_merge(inherit, "public_fields"), 
                 public_fields)
             private_fields <- merge_vectors(recursive_merge(inherit, "private_fields"), 
                 private_fields)
         }
         if (class) {
             classes <- c(classname, get_superclassnames(inherit), "R6")
         }
         else {
             classes <- NULL
         }
         has_priv <- has_private()
         if (portable) {
             if (has_priv) 
                 private_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             else private_bind_env <- NULL
             public_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             enclos_env <- new.env(parent = parent_env, hash = FALSE)
         }
         else {
             if (has_priv) {
                 private_bind_env <- new.env(parent = parent_env, hash = FALSE)
                 public_bind_env <- new.env(parent = private_bind_env, hash = FALSE)
             }
             else {
                 private_bind_env <- NULL
                 public_bind_env <- new.env(parent = parent_env, hash = FALSE)
             }
             enclos_env <- public_bind_env
         }
         enclos_env$self <- public_bind_env
         if (has_priv) 
             enclos_env$private <- private_bind_env
         public_methods <- assign_func_envs(public_methods, enclos_env)
         if (has_priv) 
             private_methods <- assign_func_envs(private_methods, enclos_env)
         if (!is.null(active)) 
             active <- assign_func_envs(active, enclos_env)
         if (length(debug_names) > 0) {
             lapply(public_methods[names(public_methods) %in% debug_names], base::debug)
             lapply(private_methods[names(private_methods) %in% debug_names], base::debug)
             lapply(active[names(active) %in% debug_names], base::debug)
         }
         if (!is.null(inherit)) {
             if (portable) {
                 super_struct <- create_super_env(inherit, public_bind_env, private_bind_env, 
                     portable = TRUE)
             }
             else {
                 super_struct <- create_super_env(inherit, public_bind_env, portable = FALSE)
             }
             enclos_env$super <- super_struct$bind_env
             public_methods <- merge_vectors(super_struct$public_methods, public_methods)
             private_methods <- merge_vectors(super_struct$private_methods, private_methods)
             active <- merge_vectors(super_struct$active, active)
         }
         list2env2(public_methods, envir = public_bind_env)
         list2env2(public_fields, envir = public_bind_env)
         if (has_priv) {
             list2env2(private_methods, envir = private_bind_env)
             list2env2(private_fields, envir = private_bind_env)
         }
         if (!is.null(active)) {
             for (name in names(active)) {
                 makeActiveBinding(name, active[[name]], public_bind_env)
             }
         }
         public_bind_env$.__enclos_env__ <- enclos_env
         if (lock_objects) {
             if (has_priv) 
                 lockEnvironment(private_bind_env)
             lockEnvironment(public_bind_env)
         }
         if (has_priv) {
             for (name in names(private_methods)) lockBinding(name, private_bind_env)
         }
         for (name in names(public_methods)) lockBinding(name, public_bind_env)
         class(public_bind_env) <- classes
         if (is.function(.subset2(public_bind_env, "initialize"))) {
             .subset2(public_bind_env, "initialize")(...)
         }
         else if (length(list(...)) != 0) {
             stop("Called new() with arguments, but there is no initialize method.")
         }
         if (is.function(.subset2(public_bind_env, "finalize"))) {
             finalizer_wrapper <- function(e) {
                 .subset2(e, "finalize")()
             }
             environment(finalizer_wrapper) <- baseenv()
             reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
         }
         if (has_priv) {
             if (is.function(.subset2(private_bind_env, "finalize"))) {
                 finalizer_wrapper <- function(e) {
                     .subset2(e, ".__enclos_env__")$private$finalize()
                 }
                 environment(finalizer_wrapper) <- baseenv()
                 reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
             }
         }
         public_bind_env
     })()
  6: .subset2(public_bind_env, "initialize")(...)
  7: super$initialize(id = "variance", packages = "stats", feature_types = c("integer", 
         "numeric"), task_type = c("classif", "regr"), param_set = ParamSet$new(list(ParamLgl$new("na.rm", 
         default = TRUE))))
  8: assert_param_set(param_set)
  9: assert_r6(param_set, "ParamSet")
  10: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  11: ParamSet$new(list(ParamLgl$new("na.rm", default = TRUE)))
  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)
  
  -- 3. Error: mlr3sugar creation works (@test_filter.R#30)  ---------------------
  not a function
  1: expect_silent(flt("correlation", method = "kendall")) at testthat/test_filter.R:30
  2: quasi_capture(enquo(object), NULL, evaluate_promise)
  3: .capture(act$val <- eval_bare(get_expr(.quo), get_env(.quo)), ...)
  4: withr::with_output_sink(temp, withCallingHandlers(withVisible(code), warning = handle_warning, 
         message = handle_message))
  5: force(code)
  6: withCallingHandlers(withVisible(code), warning = handle_warning, message = handle_message)
  7: withVisible(code)
  8: eval_bare(get_expr(.quo), get_env(.quo))
  9: flt("correlation", method = "kendall")
  10: dictionary_sugar(mlr_filters, .key, ...)
  ...
  20: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  21: ParamSet$new(list(ParamFct$new("use", default = "everything", levels = c("everything", 
         "all.obs", "complete.obs", "na.or.complete", "pairwise.complete.obs")), ParamFct$new("method", 
         default = "pearson", levels = c("pearson", "kendall", "spearman"))))
  22: .subset2(public_bind_env, "initialize")(...)
  23: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  24: map(params, function(p) p$clone(deep = TRUE))
  25: lapply(.x, .f, ...)
  26: FUN(X[[i]], ...)
  27: p$clone(deep = TRUE)
  28: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  29: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 4. Error: all classif filters return correct filter values (@test_filter_clas
  not a function
  1: mlr_filters$mget(as.data.table(mlr_filters)[map_lgl(task_type, is.element, el = "classif"), 
         key]) at testthat/test_filter_classif.R:6
  2: assert_character(keys, min.chars = 1L, any.missing = FALSE)
  3: checkCharacter(x, min.chars, pattern, fixed, ignore.case, any.missing, all.missing, 
         len, min.len, max.len, unique, sorted, names, null.ok)
  4: .Call(c_check_character, x, min.chars, any.missing, all.missing, len, min.len, max.len, 
         unique, sorted, names, null.ok) %and% checkCharacterPattern(x, pattern, fixed, 
         ignore.case)
  5: isTRUE(lhs)
  6: as.data.table(mlr_filters)
  7: as.data.table.DictionaryFilter(mlr_filters)
  8: setkeyv(map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     }), "key")
  9: is.data.table(x)
  10: map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     })
  ...
  25: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  26: ParamSet$new(list(ParamDbl$new("lambda", lower = 0, upper = 1, default = NO_DEF), 
         ParamLgl$new("diagonal", default = FALSE), ParamLgl$new("verbose", default = TRUE)))
  27: .subset2(public_bind_env, "initialize")(...)
  28: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  29: map(params, function(p) p$clone(deep = TRUE))
  30: lapply(.x, .f, ...)
  31: FUN(X[[i]], ...)
  32: p$clone(deep = TRUE)
  33: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  34: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 5. Error: all regr filters return correct filter values (@test_filter_regr.R#
  not a function
  1: mlr_filters$mget(as.data.table(mlr_filters)[map_lgl(task_type, is.element, el = "regr"), 
         key]) at testthat/test_filter_regr.R:5
  2: assert_character(keys, min.chars = 1L, any.missing = FALSE)
  3: checkCharacter(x, min.chars, pattern, fixed, ignore.case, any.missing, all.missing, 
         len, min.len, max.len, unique, sorted, names, null.ok)
  4: .Call(c_check_character, x, min.chars, any.missing, all.missing, len, min.len, max.len, 
         unique, sorted, names, null.ok) %and% checkCharacterPattern(x, pattern, fixed, 
         ignore.case)
  5: isTRUE(lhs)
  6: as.data.table(mlr_filters)
  7: as.data.table.DictionaryFilter(mlr_filters)
  8: setkeyv(map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     }), "key")
  9: is.data.table(x)
  10: map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     })
  ...
  25: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  26: ParamSet$new(list(ParamDbl$new("lambda", lower = 0, upper = 1, default = NO_DEF), 
         ParamLgl$new("diagonal", default = FALSE), ParamLgl$new("verbose", default = TRUE)))
  27: .subset2(public_bind_env, "initialize")(...)
  28: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  29: map(params, function(p) p$clone(deep = TRUE))
  30: lapply(.x, .f, ...)
  31: FUN(X[[i]], ...)
  32: p$clone(deep = TRUE)
  33: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  34: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 6. Error: Errors for unsupported features (@test_filter_regr.R#17)  ---------
  not a function
  1: mlr_filters$mget(mlr_filters$keys()) at testthat/test_filter_regr.R:17
  2: set_names(lapply(keys, self$get, ...), keys)
  3: lapply(keys, self$get, ...)
  4: FUN(X[[i]], ...)
  5: dictionary_get(self, key, ...)
  6: dictionary_initialize_item(key, obj, dots)
  7: do.call(constructor$new, cargs)
  8: (function (...) 
     {
         inherit <- get_inherit()
         if (!is.null(inherit)) {
             if (!inherits(inherit, "R6ClassGenerator")) 
                 stop("`inherit` must be a R6ClassGenerator.")
             if (!identical(portable, inherit$portable)) 
                 stop("Sub and superclass must both be portable or non-portable.")
             recursive_merge <- function(obj, which) {
                 if (is.null(obj)) 
                     return(NULL)
                 merge_vectors(recursive_merge(obj$get_inherit(), which), obj[[which]])
             }
             public_fields <- merge_vectors(recursive_merge(inherit, "public_fields"), 
                 public_fields)
             private_fields <- merge_vectors(recursive_merge(inherit, "private_fields"), 
                 private_fields)
         }
         if (class) {
             classes <- c(classname, get_superclassnames(inherit), "R6")
         }
         else {
             classes <- NULL
         }
         has_priv <- has_private()
         if (portable) {
             if (has_priv) 
                 private_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             else private_bind_env <- NULL
             public_bind_env <- new.env(parent = emptyenv(), hash = FALSE)
             enclos_env <- new.env(parent = parent_env, hash = FALSE)
         }
         else {
             if (has_priv) {
                 private_bind_env <- new.env(parent = parent_env, hash = FALSE)
                 public_bind_env <- new.env(parent = private_bind_env, hash = FALSE)
             }
             else {
                 private_bind_env <- NULL
                 public_bind_env <- new.env(parent = parent_env, hash = FALSE)
             }
             enclos_env <- public_bind_env
         }
         enclos_env$self <- public_bind_env
         if (has_priv) 
             enclos_env$private <- private_bind_env
         public_methods <- assign_func_envs(public_methods, enclos_env)
         if (has_priv) 
             private_methods <- assign_func_envs(private_methods, enclos_env)
         if (!is.null(active)) 
             active <- assign_func_envs(active, enclos_env)
         if (length(debug_names) > 0) {
             lapply(public_methods[names(public_methods) %in% debug_names], base::debug)
             lapply(private_methods[names(private_methods) %in% debug_names], base::debug)
             lapply(active[names(active) %in% debug_names], base::debug)
         }
         if (!is.null(inherit)) {
             if (portable) {
                 super_struct <- create_super_env(inherit, public_bind_env, private_bind_env, 
                     portable = TRUE)
             }
             else {
                 super_struct <- create_super_env(inherit, public_bind_env, portable = FALSE)
             }
             enclos_env$super <- super_struct$bind_env
             public_methods <- merge_vectors(super_struct$public_methods, public_methods)
             private_methods <- merge_vectors(super_struct$private_methods, private_methods)
             active <- merge_vectors(super_struct$active, active)
         }
         list2env2(public_methods, envir = public_bind_env)
         list2env2(public_fields, envir = public_bind_env)
         if (has_priv) {
             list2env2(private_methods, envir = private_bind_env)
             list2env2(private_fields, envir = private_bind_env)
         }
         if (!is.null(active)) {
             for (name in names(active)) {
                 makeActiveBinding(name, active[[name]], public_bind_env)
             }
         }
         public_bind_env$.__enclos_env__ <- enclos_env
         if (lock_objects) {
             if (has_priv) 
                 lockEnvironment(private_bind_env)
             lockEnvironment(public_bind_env)
         }
         if (has_priv) {
             for (name in names(private_methods)) lockBinding(name, private_bind_env)
         }
         for (name in names(public_methods)) lockBinding(name, public_bind_env)
         class(public_bind_env) <- classes
         if (is.function(.subset2(public_bind_env, "initialize"))) {
             .subset2(public_bind_env, "initialize")(...)
         }
         else if (length(list(...)) != 0) {
             stop("Called new() with arguments, but there is no initialize method.")
         }
         if (is.function(.subset2(public_bind_env, "finalize"))) {
             finalizer_wrapper <- function(e) {
                 .subset2(e, "finalize")()
             }
             environment(finalizer_wrapper) <- baseenv()
             reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
         }
         if (has_priv) {
             if (is.function(.subset2(private_bind_env, "finalize"))) {
                 finalizer_wrapper <- function(e) {
                     .subset2(e, ".__enclos_env__")$private$finalize()
                 }
                 environment(finalizer_wrapper) <- baseenv()
                 reg.finalizer(public_bind_env, finalizer_wrapper, onexit = TRUE)
             }
         }
         public_bind_env
     })()
  9: .subset2(public_bind_env, "initialize")(...)
  10: super$initialize(id = "carscore", packages = "care", feature_types = c("numeric"), 
         task_type = "regr", param_set = ParamSet$new(list(ParamDbl$new("lambda", lower = 0, 
             upper = 1, default = NO_DEF), ParamLgl$new("diagonal", default = FALSE), 
             ParamLgl$new("verbose", default = TRUE))))
  ...
  13: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  14: ParamSet$new(list(ParamDbl$new("lambda", lower = 0, upper = 1, default = NO_DEF), 
         ParamLgl$new("diagonal", default = FALSE), ParamLgl$new("verbose", default = TRUE)))
  15: .subset2(public_bind_env, "initialize")(...)
  16: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  17: map(params, function(p) p$clone(deep = TRUE))
  18: lapply(.x, .f, ...)
  19: FUN(X[[i]], ...)
  20: p$clone(deep = TRUE)
  21: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  22: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 7. Error: mlr_filters (@test_mlr_filters.R#4)  ------------------------------
  not a function
  1: expect_dictionary(mlr_filters, min_items = 1) at testthat/test_mlr_filters.R:4
  2: expect_data_table(data.table::as.data.table(d), key = "key", nrows = length(keys))
  3: checkDataTable(x, key, index, types, any.missing, all.missing, min.rows, max.rows, 
         min.cols, max.cols, nrows, ncols, row.names, col.names, null.ok)
  4: data.table::as.data.table(d)
  5: as.data.table.DictionaryFilter(d)
  6: setkeyv(map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     }), "key")
  7: is.data.table(x)
  8: map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     })
  9: rbindlist(unname(map(.x, .f, ...)), use.names = TRUE, fill = .fill)
  10: unname(map(.x, .f, ...))
  ...
  23: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  24: ParamSet$new(list(ParamDbl$new("lambda", lower = 0, upper = 1, default = NO_DEF), 
         ParamLgl$new("diagonal", default = FALSE), ParamLgl$new("verbose", default = TRUE)))
  25: .subset2(public_bind_env, "initialize")(...)
  26: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  27: map(params, function(p) p$clone(deep = TRUE))
  28: lapply(.x, .f, ...)
  29: FUN(X[[i]], ...)
  30: p$clone(deep = TRUE)
  31: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  32: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  -- 8. Error: praznik 'nfeat' argument works correctly (@test_partial_scoring.R#5
  not a function
  1: mlr_filters$mget(as.data.table(mlr_filters)[map_lgl(packages, is.element, el = "praznik"), 
         key]) at testthat/test_partial_scoring.R:5
  2: assert_character(keys, min.chars = 1L, any.missing = FALSE)
  3: checkCharacter(x, min.chars, pattern, fixed, ignore.case, any.missing, all.missing, 
         len, min.len, max.len, unique, sorted, names, null.ok)
  4: .Call(c_check_character, x, min.chars, any.missing, all.missing, len, min.len, max.len, 
         unique, sorted, names, null.ok) %and% checkCharacterPattern(x, pattern, fixed, 
         ignore.case)
  5: isTRUE(lhs)
  6: as.data.table(mlr_filters)
  7: as.data.table.DictionaryFilter(mlr_filters)
  8: setkeyv(map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     }), "key")
  9: is.data.table(x)
  10: map_dtr(x$keys(), function(key) {
         l = x$get(key)
         list(key = key, task_type = list(l$task_type), task_properties = list(l$task_properties), 
             param_set = list(l$param_set), feature_types = list(l$feature_types), packages = list(l$packages))
     })
  ...
  25: checkR6(x, classes, ordered, cloneable, public, private, null.ok)
  26: ParamSet$new(list(ParamDbl$new("lambda", lower = 0, upper = 1, default = NO_DEF), 
         ParamLgl$new("diagonal", default = FALSE), ParamLgl$new("verbose", default = TRUE)))
  27: .subset2(public_bind_env, "initialize")(...)
  28: set_names(map(params, function(p) p$clone(deep = TRUE)), ids)
  29: map(params, function(p) p$clone(deep = TRUE))
  30: lapply(.x, .f, ...)
  31: FUN(X[[i]], ...)
  32: p$clone(deep = TRUE)
  33: copy_slice(old[[i]], new[[i]], old_new_enclosing_pairs[seq.int(i, length(old))], 
         (i == 1))
  34: makeActiveBinding(name, active_copies[[name]], new_slice$binding)
  
  == testthat results  ===========================================================
  [ OK: 6 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 8 ]
  1. Error: FilterImportance (@test_FilterImportance.R#5) 
  2. Error: Filtering an empty Task (#39) (@test_filter.R#5) 
  3. Error: mlr3sugar creation works (@test_filter.R#30) 
  4. Error: all classif filters return correct filter values (@test_filter_classif.R#6) 
  5. Error: all regr filters return correct filter values (@test_filter_regr.R#5) 
  6. Error: Errors for unsupported features (@test_filter_regr.R#17) 
  7. Error: mlr_filters (@test_mlr_filters.R#4) 
  8. Error: praznik 'nfeat' argument works correctly (@test_partial_scoring.R#5) 
  
  Error: testthat unit tests failed
  Execution halted