Running ‘run-base.R’ [366s/479s]
Running the tests in ‘tests/run-base.R’ failed.
Complete output:
  > library(testthat)
  > test_check("mlr", filter = "base")
  Loading required package: mlr
  Loading required package: ParamHelpers
  ── 1. Error: NoFeaturesModel works with FilterWrapper (@test_base_NoFeaturesMode
  For learner classif.rpart.filtered please install the following packages: Rfast
  1: train(lrn, multiclass.task) at testthat/test_base_NoFeaturesModel.R:30
  2: requireLearnerPackages(learner)
  3: requirePackages(learner$package, why = stri_paste("learner", learner$id, sep = " "), 
         default.method = "load")
  4: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 2. Error: predict.threshold (@test_base_predict.R#129)  ─────────────────────
  For learner classif.lda.filtered please install the following packages: Rfast
  1: holdout(lrn2, binaryclass.task) at testthat/test_base_predict.R:129
  2: resample(learner, task, rdesc, measures = measures, models = models, keep.pred = keep.pred, 
         show.info = show.info)
  3: parallelMap(doResampleIteration, seq_len(rin$desc$iters), level = "mlr.resample", 
         more.args = more.args)
  4: mapply(fun2, ..., MoreArgs = more.args, SIMPLIFY = FALSE, USE.NAMES = FALSE)
  5: (function (learner, task, rin, i, measures, weights, model, extract, show.info) 
     {
         setSlaveOptions()
         if (show.info) 
             messagef("[Resample] %s iter %i: ", rin$desc$id, i, .newline = FALSE)
         train.i = rin$train.inds[[i]]
         test.i = rin$test.inds[[i]]
         calculateResampleIterationResult(learner = learner, task = task, train.i = train.i, 
             test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, 
             model = model, extract = extract, show.info = show.info)
     })(dots[[1L]][[1L]], learner = structure(list(id = "classif.lda.filtered", type = "classif", 
         package = c("Rfast", "MASS"), properties = NULL, par.set = structure(list(pars = structure(list(
             fw.method = structure(list(id = "fw.method", type = "discrete", len = 1L, 
                 lower = NULL, upper = NULL, values = structure(list(anova.test = "anova.test", 
                     carscore = "carscore", cforest.importance = "cforest.importance", 
                     chi.squared = "chi.squared", gain.ratio = "gain.ratio", information.gain = "information.gain", 
                     kruskal.test = "kruskal.test", linear.correlation = "linear.correlation", 
                     mrmr = "mrmr", oneR = "oneR", permutation.importance = "permutation.importance", 
                     randomForest.importance = "randomForest.importance", randomForestSRC.rfsrc = "randomForestSRC.rfsrc", 
                     randomForestSRC.var.select = "randomForestSRC.var.select", rank.correlation = "rank.correlation", 
                     relief = "relief", rf.importance = "rf.importance", rf.min.depth = "rf.min.depth", 
                     symmetrical.uncertainty = "symmetrical.uncertainty", univariate = "univariate", 
                     univariate.model.score = "univariate.model.score", variance = "variance"), .Names = c("anova.test", 
                 "carscore", "cforest.importance", "chi.squared", "gain.ratio", "information.gain", 
                 "kruskal.test", "linear.correlation", "mrmr", "oneR", "permutation.importance", 
                 "randomForest.importance", "randomForestSRC.rfsrc", "randomForestSRC.var.select", 
                 "rank.correlation", "relief", "rf.importance", "rf.min.depth", "symmetrical.uncertainty", 
                 "univariate", "univariate.model.score", "variance")), cnames = NULL, 
                 allow.inf = FALSE, has.default = FALSE, default = NULL, trafo = NULL, 
                 requires = NULL, tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
             "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
             "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param")), fw.perc = structure(list(id = "fw.perc", type = "numeric", len = 1L, 
                 lower = 0, upper = 1, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param")), fw.abs = structure(list(id = "fw.abs", type = "integer", len = 1L, 
                 lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param")), fw.threshold = structure(list(id = "fw.threshold", type = "numeric", 
                 len = 1L, lower = -Inf, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param")), fw.mandatory.feat = structure(list(id = "fw.mandatory.feat", type = "untyped", 
                 len = 1L, lower = NULL, upper = NULL, values = NULL, cnames = NULL, allow.inf = FALSE, 
                 has.default = FALSE, default = NULL, trafo = NULL, requires = NULL, tunable = TRUE, 
                 special.vals = list(), when = "train"), .Names = c("id", "type", "len", 
             "lower", "upper", "values", "cnames", "allow.inf", "has.default", "default", 
             "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
             "Param"))), .Names = c("fw.method", "fw.perc", "fw.abs", "fw.threshold", 
         "fw.mandatory.feat")), forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
         "ParamSet")), par.vals = structure(list(fw.method = "anova.test", fw.perc = 0.1), .Names = c("fw.method", 
         "fw.perc")), predict.type = "prob", fix.factors.prediction = FALSE, next.learner = structure(list(
             id = "classif.lda", type = "classif", package = "MASS", properties = c("twoclass", 
             "multiclass", "numerics", "factors", "prob"), par.set = structure(list(pars = structure(list(
                 method = structure(list(id = "method", type = "discrete", len = 1L, lower = NULL, 
                     upper = NULL, values = structure(list(moment = "moment", mle = "mle", 
                       mve = "mve", t = "t"), .Names = c("moment", "mle", "mve", "t")), 
                     cnames = NULL, allow.inf = FALSE, has.default = TRUE, default = "moment", 
                     trafo = NULL, requires = NULL, tunable = TRUE, special.vals = list(), 
                     when = "train"), .Names = c("id", "type", "len", "lower", "upper", 
                 "values", "cnames", "allow.inf", "has.default", "default", "trafo", "requires", 
                 "tunable", "special.vals", "when"), class = c("LearnerParam", "Param"
                 )), nu = structure(list(id = "nu", type = "numeric", len = 1L, lower = 2, 
                     upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, has.default = FALSE, 
                     default = NULL, trafo = NULL, requires = method == "t", tunable = TRUE, 
                     special.vals = list(), when = "train"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), tol = structure(list(id = "tol", type = "numeric", len = 1L, 
                     lower = 0, upper = Inf, values = NULL, cnames = NULL, allow.inf = FALSE, 
                     has.default = TRUE, default = 1e-04, trafo = NULL, requires = NULL, 
                     tunable = TRUE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), predict.method = structure(list(id = "predict.method", type = "discrete", 
                     len = 1L, lower = NULL, upper = NULL, values = structure(list(`plug-in` = "plug-in", 
                       predictive = "predictive", debiased = "debiased"), .Names = c("plug-in", 
                     "predictive", "debiased")), cnames = NULL, allow.inf = FALSE, has.default = TRUE, 
                     default = "plug-in", trafo = NULL, requires = NULL, tunable = TRUE, 
                     special.vals = list(), when = "predict"), .Names = c("id", "type", 
                 "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param")), CV = structure(list(id = "CV", type = "logical", len = 1L, 
                     lower = NULL, upper = NULL, values = structure(list(`TRUE` = TRUE, 
                       `FALSE` = FALSE), .Names = c("TRUE", "FALSE")), cnames = NULL, 
                     allow.inf = FALSE, has.default = TRUE, default = FALSE, trafo = NULL, 
                     requires = NULL, tunable = FALSE, special.vals = list(), when = "train"), .Names = c("id", 
                 "type", "len", "lower", "upper", "values", "cnames", "allow.inf", "has.default", 
                 "default", "trafo", "requires", "tunable", "special.vals", "when"), class = c("LearnerParam", 
                 "Param"))), .Names = c("method", "nu", "tol", "predict.method", "CV")), 
                 forbidden = NULL), .Names = c("pars", "forbidden"), class = c("LearnerParamSet", 
             "ParamSet")), par.vals = structure(list(), .Names = character(0)), predict.type = "prob", 
             name = "Linear Discriminant Analysis", short.name = "lda", note = "Learner parameter `predict.method` maps to `method` in `predict.lda`.", 
             config = list(), fix.factors.prediction = FALSE), .Names = c("id", "type", 
         "package", "properties", "par.set", "par.vals", "predict.type", "name", "short.name", 
         "note", "config", "fix.factors.prediction"), class = c("classif.lda", "RLearnerClassif", 
         "RLearner", "Learner")), model.subclass = "FilterModel", more.args = list(), 
         predict.threshold = 0), .Names = c("id", "type", "package", "properties", "par.set", 
     "par.vals", "predict.type", "fix.factors.prediction", "next.learner", "model.subclass", 
     "more.args", "predict.threshold"), class = c("FilterWrapper", "BaseWrapper", "Learner"
     )), task = structure(list(type = "classif", env = <environment>, weights = NULL, 
         blocking = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = structure(c(60L, 0L, 0L), .Names = c("numerics", 
             "factors", "ordered")), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             class.levels = c("M", "R"), positive = "M", negative = "R"), .Names = c("id", 
         "type", "target", "size", "n.feat", "has.missings", "has.weights", "has.blocking", 
         "class.levels", "positive", "negative"), class = c("ClassifTaskDesc", "SupervisedTaskDesc", 
         "TaskDesc"))), .Names = c("type", "env", "weights", "blocking", "task.desc"), class = c("ClassifTask", 
     "SupervisedTask", "Task")), rin = structure(list(desc = structure(list(split = 0.666666666666667, 
         id = "holdout", iters = 1L, predict = "test", stratify = FALSE), .Names = c("split", 
     "id", "iters", "predict", "stratify"), class = c("HoldoutDesc", "ResampleDesc")), 
         size = 208L, train.inds = list(c(186L, 115L, 95L, 197L, 93L, 138L, 116L, 21L, 
         180L, 49L, 9L, 65L, 188L, 174L, 135L, 124L, 191L, 126L, 194L, 103L, 112L, 55L, 
         28L, 179L, 167L, 127L, 145L, 5L, 87L, 136L, 39L, 57L, 41L, 25L, 73L, 72L, 64L, 
         27L, 24L, 40L, 79L, 45L, 143L, 8L, 195L, 131L, 20L, 91L, 34L, 201L, 120L, 141L, 
         59L, 104L, 15L, 156L, 42L, 193L, 68L, 121L, 149L, 117L, 205L, 110L, 161L, 102L, 
         1L, 150L, 31L, 53L, 85L, 199L, 16L, 33L, 90L, 56L, 105L, 14L, 177L, 128L, 207L, 
         113L, 23L, 17L, 81L, 43L, 151L, 178L, 192L, 94L, 12L, 187L, 60L, 69L, 38L, 133L, 
         107L, 54L, 98L, 100L, 66L, 44L, 185L, 99L, 32L, 7L, 97L, 164L, 154L, 147L, 119L, 
         130L, 148L, 62L, 140L, 29L, 159L, 160L, 89L, 163L, 198L, 13L, 202L, 139L, 75L, 
         183L, 61L, 123L, 203L, 146L, 206L, 76L, 144L, 170L, 182L, 142L, 134L, 86L)), 
         test.inds = list(c(50L, 51L, 173L, 101L, 78L, 196L, 125L, 77L, 208L, 157L, 111L, 
         122L, 46L, 176L, 204L, 74L, 37L, 172L, 36L, 184L, 96L, 71L, 88L, 114L, 162L, 
         47L, 155L, 18L, 92L, 70L, 106L, 171L, 82L, 166L, 30L, 2L, 6L, 132L, 58L, 168L, 
         137L, 10L, 4L, 84L, 19L, 129L, 67L, 48L, 83L, 153L, 52L, 22L, 3L, 80L, 158L, 
         190L, 108L, 152L, 175L, 189L, 109L, 165L, 181L, 11L, 63L, 35L, 200L, 118L, 169L, 
         26L)), group = structure(integer(0), .Label = character(0), class = "factor")), .Names = c("desc", 
     "size", "train.inds", "test.inds", "group"), class = "ResampleInstance"), weights = NULL, 
         measures = list(structure(list(id = "mmce", minimize = TRUE, properties = c("classif", 
         "classif.multi", "req.pred", "req.truth"), fun = function (task, model, pred, 
             feats, extra.args) 
         {
             measureMMCE(pred$data$truth, pred$data$response)
         }, extra.args = list(), best = 0, worst = 1, name = "Mean misclassification error", 
             note = "Defined as: mean(response != truth)", aggr = structure(list(id = "test.mean", 
                 name = "Test mean", fun = function (task, perf.test, perf.train, measure, 
                     group, pred) 
                 mean(perf.test), properties = "req.test"), .Names = c("id", "name", "fun", 
             "properties"), class = "Aggregation")), .Names = c("id", "minimize", "properties", 
         "fun", "extra.args", "best", "worst", "name", "note", "aggr"), class = "Measure")), 
         model = FALSE, extract = function (model) 
         {
         }, show.info = FALSE)
  6: calculateResampleIterationResult(learner = learner, task = task, train.i = train.i, 
         test.i = test.i, measures = measures, weights = weights, rdesc = rin$desc, model = model, 
         extract = extract, show.info = show.info)
  7: train(learner, task, subset = train.i, weights = weights[train.i])
  8: requireLearnerPackages(learner)
  9: requirePackages(learner$package, why = stri_paste("learner", learner$id, sep = " "), 
         default.method = "load")
  10: stopf("For %s please install the following packages: %s", why, ps)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 2708 SKIPPED: 8 FAILED: 2
  1. Error: NoFeaturesModel works with FilterWrapper (@test_base_NoFeaturesModel.R#30) 
  2. Error: predict.threshold (@test_base_predict.R#129) 
  
  Error: testthat unit tests failed
  Execution halted