Running ‘run-base.R’ [448s/543s]
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
  
  
  Attaching package: 'BBmisc'
  
  The following object is masked from 'package:base':
  
      isFALSE
  
  ── 1. Error: plotFilterValues (@test_base_generateFilterValuesData.R#68)  ──────
  argument is of length zero
  1: generateFilterValuesData(binaryclass.task, method = filter.classif) at testthat/test_base_generateFilterValuesData.R:68
  2: lapply(filter, function(x) {
         x = do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
         missing.score = setdiff(fn, names(x))
         x[missing.score] = NA_real_
         x[match(fn, names(x))]
     })
  3: FUN(X[[i]], ...)
  4: do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
  5: (function (task, nselect, method = "md", ...) 
     {
         im = randomForestSRC::var.select(getTaskFormula(task), getTaskData(task), method = method, 
             verbose = FALSE, ...)$md.obj$order
         setNames(-im[, 1L], rownames(im))
     })(task = structure(list(type = "classif", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = c(numerics = 60L, factors = 0L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE, class.levels = c("M", "R"), positive = "M", negative = "R", 
             class.distribution = structure(c(M = 111L, R = 97L), .Dim = 2L, .Dimnames = structure(list(
                 c("M", "R")), .Names = ""), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), nselect = 60L)
  6: randomForestSRC::var.select(getTaskFormula(task), getTaskData(task), method = method, 
         verbose = FALSE, ...)
  7: max.subtree(rfsrc.obj, conservative = (conservative == "high"))
  
  ── 1. Error: plotFilterValues (@test_base_generateFilterValuesData.R#68)  ──────
  write error, closing pipe to the master
  1: generateFilterValuesData(binaryclass.task, method = filter.classif) at testthat/test_base_generateFilterValuesData.R:68
  2: lapply(filter, function(x) {
         x = do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
         missing.score = setdiff(fn, names(x))
         x[missing.score] = NA_real_
         x[match(fn, names(x))]
     })
  3: FUN(X[[i]], ...)
  4: do.call(x$fun, c(list(task = task, nselect = nselect), more.args[[x$name]]))
  5: (function (task, nselect, method = "md", ...) 
     {
         im = randomForestSRC::var.select(getTaskFormula(task), getTaskData(task), method = method, 
             verbose = FALSE, ...)$md.obj$order
         setNames(-im[, 1L], rownames(im))
     })(task = structure(list(type = "classif", env = <environment>, weights = NULL, blocking = NULL, 
         coordinates = NULL, task.desc = structure(list(id = "binary", type = "classif", 
             target = "Class", size = 208L, n.feat = c(numerics = 60L, factors = 0L, ordered = 0L, 
             functionals = 0L), has.missings = FALSE, has.weights = FALSE, has.blocking = FALSE, 
             has.coordinates = FALSE, class.levels = c("M", "R"), positive = "M", negative = "R", 
             class.distribution = structure(c(M = 111L, R = 97L), .Dim = 2L, .Dimnames = structure(list(
                 c("M", "R")), .Names = ""), class = "table")), class = c("ClassifTaskDesc", 
         "SupervisedTaskDesc", "TaskDesc"))), class = c("ClassifTask", "SupervisedTask", 
     "Task")), nselect = 60L)
  6: randomForestSRC::var.select(getTaskFormula(task), getTaskData(task), method = method, 
         verbose = FALSE, ...)
  7: max.subtree(rfsrc.obj, conservative = (conservative == "high"))
  8: mclapply(1:numTree, function(b) {
         subtree <- vector("list", 8)
         names(subtree) <- c("count", "order", "meanSum", "depth", "terminalDepthSum", 
             "subOrder", "subOrderDiag", "nodesAtDepth")
         recursiveObject <- list(offset = min(which(nativeArray$treeID == b)), subtree = subtree, 
             diagnostic = 0, diagnostic2 = 0)
         recursiveObject$subtree$nodesAtDepth <- rep(NA, MAX.DEPTH)
         recursiveObject$subtree$meanSum <- rep(NA, numParm)
         recursiveObject$subtree$order <- matrix(NA, nrow = numParm, ncol = max(max.order, 
             1))
         if (sub.order) {
             recursiveObject$subtree$subOrder <- matrix(1, nrow = numParm, ncol = numParm)
             recursiveObject$subtree$subOrderDiag <- rep(NA, numParm)
         }
         recursiveObject$subtree$depth <- 0
         recursiveObject$subtree$terminalDepthSum <- 0
         recursiveObject$subtree$count <- rep(0, numParm)
         rootParmID <- nativeArray$parmID[recursiveObject$offset]
         offsetMark <- recursiveObject$offset
         stumpCnt <- 0
         recursiveObject <- rfsrcParseTree(recursiveObject, max(max.order, 1), sub.order, 
             nativeArray, b, distance = 0, subtreeFlag = rep(FALSE, numParm))
         if (rootParmID != 0) {
             index <- which(recursiveObject$subtree$count == 0)
             recursiveObject$subtree$meanSum[index] <- recursiveObject$subtree$depth
             forestMeanSum <- recursiveObject$subtree$meanSum
             index <- which(is.na(recursiveObject$subtree$order))
             recursiveObject$subtree$order[index] <- recursiveObject$subtree$depth
             orderTree <- recursiveObject$subtree$order
             subtreeCountSum <- (recursiveObject$subtree$count/((recursiveObject$offset - 
                 offsetMark + 1)/4))
             terminalDepth <- recursiveObject$subtree$terminalDepthSum/((recursiveObject$offset - 
                 offsetMark + 1)/2)
             if (sub.order) {
                 index <- which(recursiveObject$subtree$count > 0)
                 diag(recursiveObject$subtree$subOrder)[index] <- recursiveObject$subtree$subOrderDiag[index]
                 index <- which(recursiveObject$subtree$count == 0)
                 diag(recursiveObject$subtree$subOrder)[index] <- recursiveObject$subtree$depth
                 diag(recursiveObject$subtree$subOrder) <- diag(recursiveObject$subtree$subOrder)/recursiveObject$subtree$depth
                 subOrderSum <- recursiveObject$subtree$subOrder
             }
             else {
                 subOrderSum <- NULL
             }
             nodesAtDepthMatrix <- recursiveObject$subtree$nodesAtDepth
         }
         else {
             stumpCnt <- 1
             forestMeanSum <- orderTree <- subtreeCountSum <- terminalDepth <- subOrderSum <- nodesAtDepthMatrix <- NULL
         }
         return(list(forestMeanSum = forestMeanSum, orderTree = orderTree, subtreeCountSum = subtreeCountSum, 
             terminalDepth = terminalDepth, subOrderSum = subOrderSum, stumpCnt = stumpCnt, 
             nodesAtDepthMatrix = nodesAtDepthMatrix))
     })
  9: lapply(seq_len(cores), inner.do)
  10: FUN(X[[i]], ...)
  11: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
  
  ── 2. Error: tuning allows usage of budget (@test_base_tuning.R#120)  ──────────
  Assertion on 'discrete.names' failed: Must be of type 'logical flag', not 'NULL'.
  1: tuneParams(lrn, binaryclass.task, resampling = rdesc, par.set = ps, control = ctrl) at testthat/test_base_tuning.R:120
  2: sel.func(learner, task, resampling, measures, par.set, control, opt.path, show.info, 
         resample.fun)
  3: sampleValue(par.set, start, trafo = FALSE)
  4: sampleValue.ParamSet(par.set, start, trafo = FALSE)
  5: lapply(par$pars, sampleValue, discrete.names = discrete.names, trafo = trafo)
  6: FUN(X[[i]], ...)
  7: sampleValue.Param(X[[i]], ...)
  8: assertFlag(discrete.names)
  9: makeAssertion(x, res, .var.name, add)
  10: mstop("Assertion on '%s' failed: %s.", var.name, res)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 3578 SKIPPED: 0 FAILED: 2
  1. Error: plotFilterValues (@test_base_generateFilterValuesData.R#68) 
  2. Error: tuning allows usage of budget (@test_base_tuning.R#120) 
  
  Error: testthat unit tests failed
  Execution halted