Running ‘run-base.R’ [9m/11m]
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
  
  Attaching package: 'rex'
  
  The following object is masked from 'package:testthat':
  
      matches
  
  ── 1. Error: getHyperPars (@test_base_getHyperPars.R#19)  ──────────────────────
  For learner multilabel.rFerns please install the following packages: rFerns
  1: makeLearner("multilabel.rFerns") at testthat/test_base_getHyperPars.R:19
  2: do.call(constructor, list())
  3: (function () 
     {
         makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
             default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
             "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
     })()
  4: makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
         default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
         "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
  5: addClasses(makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerMultilabel"))
  6: makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  7: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  8: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 2. Error: WeightedClassesWrapper, binary (@test_base_imbal_weightedclasses.R#
  For learner classif.LiblineaRL1L2SVC please install the following packages: LiblineaR
  1: lapply(learners, function(lrn) {
         cm1 = f(lrn, 0.001)
         cm2 = f(lrn, 1)
         cm3 = f(lrn, 1000)
         expect_true(all(cm1[, pos] <= cm2[, pos]))
         expect_true(all(cm2[, pos] <= cm3[, pos]))
     }) at testthat/test_base_imbal_weightedclasses.R:16
  2: FUN(X[[i]], ...)
  3: f(lrn, 0.001) at testthat/test_base_imbal_weightedclasses.R:17
  4: makeLearner(lrn) at testthat/test_base_imbal_weightedclasses.R:6
  5: do.call(constructor, list())
  6: (function () 
     {
         makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
             default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
             lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
             len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
             tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, 
             tunable = FALSE)), properties = c("twoclass", "multiclass", "numerics", "class.weights"), 
             class.weights.param = "wi", name = "L1-Regularized L2-Loss Support Vector Classification", 
             short.name = "liblinl1l2svc", callees = "LiblineaR")
     })()
  7: makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
         default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
         lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
         len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
         tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, tunable = FALSE)), 
         properties = c("twoclass", "multiclass", "numerics", "class.weights"), class.weights.param = "wi", 
         name = "L1-Regularized L2-Loss Support Vector Classification", short.name = "liblinl1l2svc", 
         callees = "LiblineaR")
  8: addClasses(makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerClassif"))
  9: makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  10: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  11: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 3. Error: WeightedClassesWrapper, multiclass (@test_base_imbal_weightedclasse
  For learner classif.LiblineaRL1L2SVC please install the following packages: LiblineaR
  1: lapply(learners, function(lrn) {
         classes = getTaskFactorLevels(multiclass.task)[[multiclass.target]]
         n = length(classes)
         cm1 = f(lrn, setNames(object = c(10000, 1, 1), classes))
         cm2 = f(lrn, setNames(object = c(1, 10000, 1), classes))
         cm3 = f(lrn, setNames(object = c(1, 1, 10000), classes))
         expect_true(all(cm1[, levs[1]] >= cm2[, levs[1]]))
         expect_true(all(cm1[, levs[1]] >= cm3[, levs[1]]))
         expect_true(all(cm2[, levs[2]] >= cm1[, levs[2]]))
         expect_true(all(cm2[, levs[2]] >= cm3[, levs[2]]))
         expect_true(all(cm3[, levs[3]] >= cm1[, levs[3]]))
         expect_true(all(cm3[, levs[3]] >= cm2[, levs[3]]))
     }) at testthat/test_base_imbal_weightedclasses.R:41
  2: FUN(X[[i]], ...)
  3: f(lrn, setNames(object = c(10000, 1, 1), classes)) at testthat/test_base_imbal_weightedclasses.R:44
  4: makeLearner(lrn) at testthat/test_base_imbal_weightedclasses.R:31
  5: do.call(constructor, list())
  6: (function () 
     {
         makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
             default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
             lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
             len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
             tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, 
             tunable = FALSE)), properties = c("twoclass", "multiclass", "numerics", "class.weights"), 
             class.weights.param = "wi", name = "L1-Regularized L2-Loss Support Vector Classification", 
             short.name = "liblinl1l2svc", callees = "LiblineaR")
     })()
  7: makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
         default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
         lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
         len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
         tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, tunable = FALSE)), 
         properties = c("twoclass", "multiclass", "numerics", "class.weights"), class.weights.param = "wi", 
         name = "L1-Regularized L2-Loss Support Vector Classification", short.name = "liblinl1l2svc", 
         callees = "LiblineaR")
  8: addClasses(makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerClassif"))
  9: makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  10: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  11: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 4. Error: getClassWeightParam (@test_base_imbal_weightedclasses.R#72)  ──────
  For learner classif.LiblineaRL1L2SVC please install the following packages: LiblineaR
  1: lapply(learners, f) at testthat/test_base_imbal_weightedclasses.R:72
  2: FUN(X[[i]], ...)
  3: makeLearner(lrn) at testthat/test_base_imbal_weightedclasses.R:64
  4: do.call(constructor, list())
  5: (function () 
     {
         makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
             default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
             lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
             len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
             tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, 
             tunable = FALSE)), properties = c("twoclass", "multiclass", "numerics", "class.weights"), 
             class.weights.param = "wi", name = "L1-Regularized L2-Loss Support Vector Classification", 
             short.name = "liblinl1l2svc", callees = "LiblineaR")
     })()
  6: makeRLearnerClassif(cl = "classif.LiblineaRL1L2SVC", package = "LiblineaR", par.set = makeParamSet(makeNumericLearnerParam(id = "cost", 
         default = 1, lower = 0), makeNumericLearnerParam(id = "epsilon", default = 0.01, 
         lower = 0), makeLogicalLearnerParam(id = "bias", default = TRUE), makeNumericVectorLearnerParam(id = "wi", 
         len = NA_integer_), makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, 
         tunable = FALSE), makeLogicalLearnerParam(id = "verbose", default = FALSE, tunable = FALSE)), 
         properties = c("twoclass", "multiclass", "numerics", "class.weights"), class.weights.param = "wi", 
         name = "L1-Regularized L2-Loss Support Vector Classification", short.name = "liblinl1l2svc", 
         callees = "LiblineaR")
  7: addClasses(makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerClassif"))
  8: makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  9: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  10: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 5. Error: measures (@test_base_measures.R#53)  ──────────────────────────────
  Please install the following packages: Hmisc
  1: performance(pred, model = mod, task = surv.task, measures = ms) at testthat/test_base_measures.R:53
  2: vnapply(measures, doPerformanceIteration, pred = pred, task = task, model = model, 
         td = NULL, feats = feats)
  3: vapply(X = x, FUN = fun, ..., FUN.VALUE = NA_real_, USE.NAMES = use.names)
  4: FUN(X[[i]], ...)
  5: measure$fun(task, model, pred, feats, m$extra.args)
  6: requirePackages("_Hmisc")
  7: stopf("Please install the following packages: %s", ps)
  
  ── 6. Error: check measure calculations (@test_base_measures.R#171)  ───────────
  For learner multilabel.rFerns please install the following packages: rFerns
  1: makeLearner("multilabel.rFerns") at testthat/test_base_measures.R:171
  2: do.call(constructor, list())
  3: (function () 
     {
         makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
             default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
             "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
     })()
  4: makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
         default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
         "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
  5: addClasses(makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerMultilabel"))
  6: makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  7: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  8: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 7. Error: multilabel learning (@test_base_multilabel.R#15)  ─────────────────
  For learner multilabel.rFerns please install the following packages: rFerns
  1: makeLearner("multilabel.rFerns") at testthat/test_base_multilabel.R:15
  2: do.call(constructor, list())
  3: (function () 
     {
         makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
             default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
             "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
     })()
  4: makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
         default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
         "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
  5: addClasses(makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerMultilabel"))
  6: makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  7: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  8: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 8. Error: predict preserves rownames (@test_base_predict.R#92)  ─────────────
  For learner classif.kknn please install the following packages: kknn
  1: train("classif.kknn", task = task) at testthat/test_base_predict.R:92
  2: checkLearner(learner)
  3: makeLearner(learner)
  4: do.call(constructor, list())
  5: (function () 
     {
         makeRLearnerClassif(cl = "classif.kknn", package = "!kknn", par.set = makeParamSet(makeIntegerLearnerParam(id = "k", 
             default = 7L, lower = 1L), makeNumericLearnerParam(id = "distance", default = 2, 
             lower = 0), makeDiscreteLearnerParam(id = "kernel", default = "optimal", 
             values = list("rectangular", "triangular", "epanechnikov", "biweight", "triweight", 
                 "cos", "inv", "gaussian", "optimal")), makeLogicalLearnerParam(id = "scale", 
             default = TRUE)), properties = c("twoclass", "multiclass", "numerics", "factors", 
             "prob"), name = "k-Nearest Neighbor", short.name = "kknn", callees = "kknn")
     })()
  6: makeRLearnerClassif(cl = "classif.kknn", package = "!kknn", par.set = makeParamSet(makeIntegerLearnerParam(id = "k", 
         default = 7L, lower = 1L), makeNumericLearnerParam(id = "distance", default = 2, 
         lower = 0), makeDiscreteLearnerParam(id = "kernel", default = "optimal", values = list("rectangular", 
         "triangular", "epanechnikov", "biweight", "triweight", "cos", "inv", "gaussian", 
         "optimal")), makeLogicalLearnerParam(id = "scale", default = TRUE)), properties = c("twoclass", 
         "multiclass", "numerics", "factors", "prob"), name = "k-Nearest Neighbor", short.name = "kknn", 
         callees = "kknn")
  7: addClasses(makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerClassif"))
  8: makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  9: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  10: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 9. Error: (unknown) (@test_base_prediction_operators.R#5)  ──────────────────
  For learner multilabel.rFerns please install the following packages: rFerns
  1: predict(train("multilabel.rFerns", multilabel.task), multilabel.task) at testthat/test_base_prediction_operators.R:5
  2: train("multilabel.rFerns", multilabel.task)
  3: checkLearner(learner)
  4: makeLearner(learner)
  5: do.call(constructor, list())
  6: (function () 
     {
         makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
             default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
             "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
     })()
  7: makeRLearnerMultilabel(cl = "multilabel.rFerns", package = "rFerns", par.set = makeParamSet(makeIntegerLearnerParam(id = "depth", 
         default = 5L), makeIntegerLearnerParam(id = "ferns", default = 1000L)), properties = c("numerics", 
         "factors", "ordered"), name = "Random ferns", short.name = "rFerns", callees = "rFerns")
  8: addClasses(makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerMultilabel"))
  9: makeRLearnerInternal(cl, "multilabel", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  10: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  11: stopf("For %s please install the following packages: %s", why, ps)
  
  ── 10. Error: selectFeatures/sfs works with wrapper (@test_base_selectFeatures.R
  For learner classif.LiblineaRL2LogReg please install the following packages: LiblineaR
  1: makeLearner("classif.LiblineaRL2LogReg") at testthat/test_base_selectFeatures.R:64
  2: do.call(constructor, list())
  3: (function () 
     {
         makeRLearnerClassif(cl = "classif.LiblineaRL2LogReg", package = "LiblineaR", 
             par.set = makeParamSet(makeDiscreteLearnerParam(id = "type", default = 0L, 
                 values = c(0L, 7L)), makeNumericLearnerParam(id = "cost", default = 1, 
                 lower = 0), makeNumericLearnerParam(id = "epsilon", lower = 0), makeLogicalLearnerParam(id = "bias", 
                 default = TRUE), makeNumericVectorLearnerParam(id = "wi", len = NA_integer_), 
                 makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, tunable = FALSE), 
                 makeLogicalLearnerParam(id = "verbose", default = FALSE, tunable = FALSE)), 
             par.vals = list(type = 0L), properties = c("twoclass", "multiclass", "numerics", 
                 "class.weights", "prob"), class.weights.param = "wi", name = "L2-Regularized Logistic Regression", 
             short.name = "liblinl2logreg", note = "`type = 0` (the default) is primal and `type = 7` is dual problem.", 
             callees = "LiblineaR")
     })()
  4: makeRLearnerClassif(cl = "classif.LiblineaRL2LogReg", package = "LiblineaR", par.set = makeParamSet(makeDiscreteLearnerParam(id = "type", 
         default = 0L, values = c(0L, 7L)), makeNumericLearnerParam(id = "cost", default = 1, 
         lower = 0), makeNumericLearnerParam(id = "epsilon", lower = 0), makeLogicalLearnerParam(id = "bias", 
         default = TRUE), makeNumericVectorLearnerParam(id = "wi", len = NA_integer_), 
         makeIntegerLearnerParam(id = "cross", default = 0L, lower = 0L, tunable = FALSE), 
         makeLogicalLearnerParam(id = "verbose", default = FALSE, tunable = FALSE)), par.vals = list(type = 0L), 
         properties = c("twoclass", "multiclass", "numerics", "class.weights", "prob"), 
         class.weights.param = "wi", name = "L2-Regularized Logistic Regression", short.name = "liblinl2logreg", 
         note = "`type = 0` (the default) is primal and `type = 7` is dual problem.", 
         callees = "LiblineaR")
  5: addClasses(makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, 
         name, short.name, note, callees), c(cl, "RLearnerClassif"))
  6: makeRLearnerInternal(cl, "classif", package, par.set, par.vals, properties, name, 
         short.name, note, callees)
  7: requirePackages(package, why = stri_paste("learner", id, sep = " "), default.method = "load")
  8: stopf("For %s please install the following packages: %s", why, ps)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 3245 SKIPPED: 0 FAILED: 10
  1.  Error: getHyperPars (@test_base_getHyperPars.R#19) 
  2.  Error: WeightedClassesWrapper, binary (@test_base_imbal_weightedclasses.R#16) 
  3.  Error: WeightedClassesWrapper, multiclass (@test_base_imbal_weightedclasses.R#41) 
  4.  Error: getClassWeightParam (@test_base_imbal_weightedclasses.R#72) 
  5.  Error: measures (@test_base_measures.R#53) 
  6.  Error: check measure calculations (@test_base_measures.R#171) 
  7.  Error: multilabel learning (@test_base_multilabel.R#15) 
  8.  Error: predict preserves rownames (@test_base_predict.R#92) 
  9.  Error: (unknown) (@test_base_prediction_operators.R#5) 
  10. Error: selectFeatures/sfs works with wrapper (@test_base_selectFeatures.R#64) 
  
  Error: testthat unit tests failed
  Execution halted