CRAN Package Check Results for Package classiFunc

Last updated on 2020-02-15 01:01:20 CET.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.1.1 11.25 114.66 125.91 ERROR
r-devel-linux-x86_64-debian-gcc 0.1.1 9.21 90.39 99.60 ERROR
r-devel-linux-x86_64-fedora-clang 0.1.1 152.30 ERROR
r-devel-linux-x86_64-fedora-gcc 0.1.1 150.75 ERROR
r-devel-windows-ix86+x86_64 0.1.1 20.00 136.00 156.00 OK
r-devel-windows-ix86+x86_64-gcc8 0.1.1 48.00 179.00 227.00 OK
r-patched-linux-x86_64 0.1.1 10.28 107.02 117.30 OK
r-patched-solaris-x86 0.1.1 227.30 ERROR
r-release-linux-x86_64 0.1.1 9.83 105.58 115.41 OK
r-release-windows-ix86+x86_64 0.1.1 23.00 122.00 145.00 OK
r-release-osx-x86_64 0.1.1 OK
r-oldrel-windows-ix86+x86_64 0.1.1 13.00 111.00 124.00 OK
r-oldrel-osx-x86_64 0.1.1 OK

Check Details

Version: 0.1.1
Check: tests
Result: ERROR
     Running 'testthat.R' [18s/20s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(classiFunc)
     >
     > test_check("classiFunc")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#34: classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKernel.R#31: test_that("classiKernel works for different Kernels", {
     data(phoneme, package = "fda.usc")
     mod1 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     mod2 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     h = 0.1, ker = "Ker.epa")
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE, nrows = nrow(mod1$fdata),
     ncols = length(unique(mod1$classes)))
     pred1.2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "prob")
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat, predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE, levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x5afb048>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#65: classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKernel.R#65: expect_warning({
     mod1 = classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKernel.R#53: test_that("classiKernel works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"])
     })
     expect_warning({
     mod2 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"], h = 10000)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "prob")
     checkmate::expect_matrix(pred2, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred3 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::assert_true(all(pred3 == 1))
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x5afb048>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 2. Error: classiKernel works for DTI data set (contains missing values) (@tes
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#35: classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#32: test_that("classiKnn works for phoneme data set from fda.usc package",
     {
     data(phoneme, package = "fda.usc")
     mod1 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     mod2 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     nderiv = 1L, knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(unique(mod1$classes)))
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x5af2c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 3. Error: classiKnn works for phoneme data set from fda.usc package (@test_cl
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#103: classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKnn.R#103: expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKnn.R#91: test_that("classiKnn works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     expect_warning({
     mod2 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"], nderiv = 1L, knn = 3L)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = DTI[1, "cca"], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x5af2c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 4. Error: classiKnn works for DTI data set (contains missing values) (@test_c
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#132: classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#122: test_that("classiKnn works for growth data set (contains irregular grid)",
     {
     data(Growth_irregular, package = "classiFunc")
     Growth = Growth_irregular
     classes = Growth$sex
     set.seed(123)
     train_inds = sample(1:length(classes), size = 0.8 * length(classes),
     replace = FALSE)
     test_inds = (1:length(classes))[!(1:length(classes)) %in%
     train_inds]
     mod1 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     mod2 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ], nderiv = 1L,
     knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x5af2c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 5. Error: classiKnn works for growth data set (contains irregular grid) (@tes
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_parallelComputeDistMat.R#22: classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_parallelComputeDistMat.R#17: test_that("Works with kernel / knn", {
     set.seed(123)
     trn = matrix(rnorm(n = 20), 5, byrow = TRUE)
     tst = matrix(rnorm(n = 40), 10, byrow = TRUE)
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L,
     metric = "shortEuclidean", dmin = 0, dmax = 1/2)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     if (require("dtw")) {
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 2L,
     metric = "dtw")
     pred = predict(mod, newdata = tst)
     expect_message({
     pred2 = predict(mod, newdata = tst, parallel = TRUE,
     batches = 3)
     }, "Loading")
     expect_true(all.equal(pred, pred2))
     }
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x5af2c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     -- 6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22) ------
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
    
     == testthat results ===========================================================
     [ OK: 34 | SKIPPED: 0 | WARNINGS: 784 | FAILED: 6 ]
     1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     2. Error: classiKernel works for DTI data set (contains missing values) (@test_classiKernel.R#65)
     3. Error: classiKnn works for phoneme data set from fda.usc package (@test_classiKnn.R#35)
     4. Error: classiKnn works for DTI data set (contains missing values) (@test_classiKnn.R#103)
     5. Error: classiKnn works for growth data set (contains irregular grid) (@test_classiKnn.R#132)
     6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.1.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [15s/20s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(classiFunc)
     >
     > test_check("classiFunc")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#34: classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKernel.R#31: test_that("classiKernel works for different Kernels", {
     data(phoneme, package = "fda.usc")
     mod1 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     mod2 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     h = 0.1, ker = "Ker.epa")
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE, nrows = nrow(mod1$fdata),
     ncols = length(unique(mod1$classes)))
     pred1.2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "prob")
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat, predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE, levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x559afd08bd70>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#65: classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKernel.R#65: expect_warning({
     mod1 = classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKernel.R#53: test_that("classiKernel works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"])
     })
     expect_warning({
     mod2 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"], h = 10000)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "prob")
     checkmate::expect_matrix(pred2, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred3 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::assert_true(all(pred3 == 1))
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x559afd08bd70>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 2. Error: classiKernel works for DTI data set (contains missing values) (@tes
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#35: classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#32: test_that("classiKnn works for phoneme data set from fda.usc package",
     {
     data(phoneme, package = "fda.usc")
     mod1 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     mod2 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     nderiv = 1L, knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(unique(mod1$classes)))
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x559afd083c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 3. Error: classiKnn works for phoneme data set from fda.usc package (@test_cl
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#103: classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKnn.R#103: expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKnn.R#91: test_that("classiKnn works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     expect_warning({
     mod2 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"], nderiv = 1L, knn = 3L)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = DTI[1, "cca"], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x559afd083c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 4. Error: classiKnn works for DTI data set (contains missing values) (@test_c
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#132: classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#122: test_that("classiKnn works for growth data set (contains irregular grid)",
     {
     data(Growth_irregular, package = "classiFunc")
     Growth = Growth_irregular
     classes = Growth$sex
     set.seed(123)
     train_inds = sample(1:length(classes), size = 0.8 * length(classes),
     replace = FALSE)
     test_inds = (1:length(classes))[!(1:length(classes)) %in%
     train_inds]
     mod1 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     mod2 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ], nderiv = 1L,
     knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x559afd083c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 5. Error: classiKnn works for growth data set (contains irregular grid) (@tes
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_parallelComputeDistMat.R#22: classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_parallelComputeDistMat.R#17: test_that("Works with kernel / knn", {
     set.seed(123)
     trn = matrix(rnorm(n = 20), 5, byrow = TRUE)
     tst = matrix(rnorm(n = 40), 10, byrow = TRUE)
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L,
     metric = "shortEuclidean", dmin = 0, dmax = 1/2)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     if (require("dtw")) {
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 2L,
     metric = "dtw")
     pred = predict(mod, newdata = tst)
     expect_message({
     pred2 = predict(mod, newdata = tst, parallel = TRUE,
     batches = 3)
     }, "Loading")
     expect_true(all.equal(pred, pred2))
     }
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x559afd083c90>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22) ──────
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 34 | SKIPPED: 0 | WARNINGS: 784 | FAILED: 6 ]
     1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     2. Error: classiKernel works for DTI data set (contains missing values) (@test_classiKernel.R#65)
     3. Error: classiKnn works for phoneme data set from fda.usc package (@test_classiKnn.R#35)
     4. Error: classiKnn works for DTI data set (contains missing values) (@test_classiKnn.R#103)
     5. Error: classiKnn works for growth data set (contains irregular grid) (@test_classiKnn.R#132)
     6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 0.1.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [21s/23s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(classiFunc)
     >
     > test_check("classiFunc")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#34: classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKernel.R#31: test_that("classiKernel works for different Kernels", {
     data(phoneme, package = "fda.usc")
     mod1 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     mod2 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     h = 0.1, ker = "Ker.epa")
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE, nrows = nrow(mod1$fdata),
     ncols = length(unique(mod1$classes)))
     pred1.2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "prob")
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat, predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE, levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x6bfaba0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#65: classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKernel.R#65: expect_warning({
     mod1 = classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKernel.R#53: test_that("classiKernel works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"])
     })
     expect_warning({
     mod2 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"], h = 10000)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "prob")
     checkmate::expect_matrix(pred2, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred3 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::assert_true(all(pred3 == 1))
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x6bfaba0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 2. Error: classiKernel works for DTI data set (contains missing values) (@tes
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#35: classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#32: test_that("classiKnn works for phoneme data set from fda.usc package",
     {
     data(phoneme, package = "fda.usc")
     mod1 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     mod2 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     nderiv = 1L, knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(unique(mod1$classes)))
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x6bf2858>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 3. Error: classiKnn works for phoneme data set from fda.usc package (@test_cl
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#103: classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKnn.R#103: expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKnn.R#91: test_that("classiKnn works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     expect_warning({
     mod2 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"], nderiv = 1L, knn = 3L)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = DTI[1, "cca"], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x6bf2858>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 4. Error: classiKnn works for DTI data set (contains missing values) (@test_c
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#132: classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#122: test_that("classiKnn works for growth data set (contains irregular grid)",
     {
     data(Growth_irregular, package = "classiFunc")
     Growth = Growth_irregular
     classes = Growth$sex
     set.seed(123)
     train_inds = sample(1:length(classes), size = 0.8 * length(classes),
     replace = FALSE)
     test_inds = (1:length(classes))[!(1:length(classes)) %in%
     train_inds]
     mod1 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     mod2 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ], nderiv = 1L,
     knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x6bf2858>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 5. Error: classiKnn works for growth data set (contains irregular grid) (@tes
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_parallelComputeDistMat.R#22: classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_parallelComputeDistMat.R#17: test_that("Works with kernel / knn", {
     set.seed(123)
     trn = matrix(rnorm(n = 20), 5, byrow = TRUE)
     tst = matrix(rnorm(n = 40), 10, byrow = TRUE)
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L,
     metric = "shortEuclidean", dmin = 0, dmax = 1/2)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     if (require("dtw")) {
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 2L,
     metric = "dtw")
     pred = predict(mod, newdata = tst)
     expect_message({
     pred2 = predict(mod, newdata = tst, parallel = TRUE,
     batches = 3)
     }, "Loading")
     expect_true(all.equal(pred, pred2))
     }
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x6bf2858>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22) ──────
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 34 | SKIPPED: 0 | WARNINGS: 784 | FAILED: 6 ]
     1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     2. Error: classiKernel works for DTI data set (contains missing values) (@test_classiKernel.R#65)
     3. Error: classiKnn works for phoneme data set from fda.usc package (@test_classiKnn.R#35)
     4. Error: classiKnn works for DTI data set (contains missing values) (@test_classiKnn.R#103)
     5. Error: classiKnn works for growth data set (contains irregular grid) (@test_classiKnn.R#132)
     6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang

Version: 0.1.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [22s/24s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(classiFunc)
     >
     > test_check("classiFunc")
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#34: classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKernel.R#31: test_that("classiKernel works for different Kernels", {
     data(phoneme, package = "fda.usc")
     mod1 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     ker = "Ker.norm", h = 50)
     mod2 = classiKernel(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     h = 0.1, ker = "Ker.epa")
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE, nrows = nrow(mod1$fdata),
     ncols = length(unique(mod1$classes)))
     pred1.2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "prob")
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat, predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE, levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x725e3c8>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKernel.R#65: classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKernel.R#65: expect_warning({
     mod1 = classiKernel(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKernel.R#53: test_that("classiKernel works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"])
     })
     expect_warning({
     mod2 = classiKernel(classes = classes[train_inds],
     fdata = DTI[train_inds, "cca"], h = 10000)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "prob")
     checkmate::expect_matrix(pred2, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred3 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::assert_true(all(pred3 == 1))
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), h = 1, metric = "L2",
     ker = "Ker.norm", nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, custom.ker = function(u) {
     return(dnorm(u))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertNumeric(h, lower = 0, len = 1L)
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     assertChoice(ker, choices = kerChoices())
     assertChoice(metric, choices = metricChoices())
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !checkmate::anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     if (ker != "custom.ker")
     custom.ker = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, h = h, metric = metric, ker = ker, custom.metric = custom.metric,
     custom.ker = custom.ker, nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKernel"
     return(ret)
     }
     <bytecode: 0x725e3c8>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKernel in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 2. Error: classiKernel works for DTI data set (contains missing values) (@tes
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKernel(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#35: classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#32: test_that("classiKnn works for phoneme data set from fda.usc package",
     {
     data(phoneme, package = "fda.usc")
     mod1 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
     mod2 = classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data,
     nderiv = 1L, knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(unique(mod1$classes)))
     pred2 = predict(mod2, newdata = phoneme[["test"]]$dat,
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(phoneme[["classtest"]]))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x7259eb0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 3. Error: classiKnn works for phoneme data set from fda.usc package (@test_cl
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(classes = phoneme[["classlearn"]], fdata = phoneme[["learn"]]$data)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#103: classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     where 2: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     where 3: withCallingHandlers(code, warning = function(condition) {
     out$push(condition)
     maybe_restart("muffleWarning")
     })
     where 4: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),
     ...)
     where 5: quasi_capture(enquo(object), label, capture_warnings)
     where 6 at testthat/test_classiKnn.R#103: expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     where 7: eval(code, test_env)
     where 8: eval(code, test_env)
     where 9: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 10: doTryCatch(return(expr), name, parentenv, handler)
     where 11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 13: doTryCatch(return(expr), name, parentenv, handler)
     where 14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 15: tryCatchList(expr, classes, parentenv, handlers)
     where 16: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 17: test_code(desc, code, env = parent.frame())
     where 18 at testthat/test_classiKnn.R#91: test_that("classiKnn works for DTI data set (contains missing values)",
     {
     data("DTI_original")
     DTI = DTI_original
     classes = DTI[, "case"]
     set.seed(123)
     train_inds = sample(1:nrow(DTI), size = 0.8 * nrow(DTI),
     replace = FALSE)
     test_inds = (1:nrow(DTI))[!(1:nrow(DTI)) %in% train_inds]
     DTI = DTI[, !colnames(DTI) == "target"]
     expect_warning({
     mod1 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"])
     })
     expect_warning({
     mod2 = classiKnn(classes = classes[train_inds], fdata = DTI[train_inds,
     "cca"], nderiv = 1L, knn = 3L)
     })
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = DTI[train_inds, "cca"],
     predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = DTI[1, "cca"], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 19: eval(code, test_env)
     where 20: eval(code, test_env)
     where 21: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 22: doTryCatch(return(expr), name, parentenv, handler)
     where 23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 25: doTryCatch(return(expr), name, parentenv, handler)
     where 26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 27: tryCatchList(expr, classes, parentenv, handlers)
     where 28: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 29: test_code(NULL, exprs, env)
     where 30: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 31: force(code)
     where 32: doWithOneRestart(return(expr), restart)
     where 33: withOneRestart(expr, restarts[[1L]])
     where 34: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 35: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 36: FUN(X[[i]], ...)
     where 37: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 38: force(code)
     where 39: doWithOneRestart(return(expr), restart)
     where 40: withOneRestart(expr, restarts[[1L]])
     where 41: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 42: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 43: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 44: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 45: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 46: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x7259eb0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 4. Error: classiKnn works for DTI data set (contains missing values) (@test_c
     the condition has length > 1
     Backtrace:
     1. testthat::expect_warning(...)
     6. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_classiKnn.R#132: classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_classiKnn.R#122: test_that("classiKnn works for growth data set (contains irregular grid)",
     {
     data(Growth_irregular, package = "classiFunc")
     Growth = Growth_irregular
     classes = Growth$sex
     set.seed(123)
     train_inds = sample(1:length(classes), size = 0.8 * length(classes),
     replace = FALSE)
     test_inds = (1:length(classes))[!(1:length(classes)) %in%
     train_inds]
     mod1 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ])
     mod2 = classiKnn(classes = classes[train_inds], grid = Growth$age_grid,
     fdata = Growth$height[train_inds, ], nderiv = 1L,
     knn = 3L)
     pred1 = predict(mod1, predict.type = "prob")
     checkmate::expect_matrix(pred1, any.missing = FALSE,
     nrows = nrow(mod1$fdata), ncols = length(levels(mod1$classes)))
     pred2 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred2, any.missing = FALSE,
     levels = levels(mod2$classes))
     pred3 = predict(mod2, newdata = Growth$height[test_inds,
     ], predict.type = "response")
     checkmate::expect_factor(pred3, any.missing = FALSE,
     levels = levels(mod2$classes))
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x7259eb0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 5. Error: classiKnn works for growth data set (contains irregular grid) (@tes
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(...)
    
     ----------- FAILURE REPORT --------------
     --- failure: the condition has length > 1 ---
     --- srcref ---
     :
     --- package (from environment) ---
     classiFunc
     --- call from context ---
     classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     --- call from argument ---
     if (class(fdata) == "data.frame") fdata = as.matrix(fdata)
     --- R stacktrace ---
     where 1 at testthat/test_parallelComputeDistMat.R#22: classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     where 2: eval(code, test_env)
     where 3: eval(code, test_env)
     where 4: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 5: doTryCatch(return(expr), name, parentenv, handler)
     where 6: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 7: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 8: doTryCatch(return(expr), name, parentenv, handler)
     where 9: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 10: tryCatchList(expr, classes, parentenv, handlers)
     where 11: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 12: test_code(desc, code, env = parent.frame())
     where 13 at testthat/test_parallelComputeDistMat.R#17: test_that("Works with kernel / knn", {
     set.seed(123)
     trn = matrix(rnorm(n = 20), 5, byrow = TRUE)
     tst = matrix(rnorm(n = 40), 10, byrow = TRUE)
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L,
     metric = "shortEuclidean", dmin = 0, dmax = 1/2)
     pred = predict(mod, newdata = tst)
     pred2 = predict(mod, newdata = tst, parallel = TRUE, batches = 2)
     expect_true(all.equal(pred, pred2))
     if (require("dtw")) {
     mod = classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 2L,
     metric = "dtw")
     pred = predict(mod, newdata = tst)
     expect_message({
     pred2 = predict(mod, newdata = tst, parallel = TRUE,
     batches = 3)
     }, "Loading")
     expect_true(all.equal(pred, pred2))
     }
     })
     where 14: eval(code, test_env)
     where 15: eval(code, test_env)
     where 16: withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error)
     where 17: doTryCatch(return(expr), name, parentenv, handler)
     where 18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     where 19: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     where 20: doTryCatch(return(expr), name, parentenv, handler)
     where 21: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),
     names[nh], parentenv, handlers[[nh]])
     where 22: tryCatchList(expr, classes, parentenv, handlers)
     where 23: tryCatch(withCallingHandlers({
     eval(code, test_env)
     if (!handled && !is.null(test)) {
     skip_empty()
     }
     }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning,
     message = handle_message, error = handle_error), error = handle_fatal,
     skip = function(e) {
     })
     where 24: test_code(NULL, exprs, env)
     where 25: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
     where 26: force(code)
     where 27: doWithOneRestart(return(expr), restart)
     where 28: withOneRestart(expr, restarts[[1L]])
     where 29: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 30: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter,
     {
     reporter$start_file(basename(path))
     lister$start_file(basename(path))
     source_file(path, new.env(parent = env), chdir = TRUE,
     wrap = wrap)
     reporter$.end_context()
     reporter$end_file()
     })
     where 31: FUN(X[[i]], ...)
     where 32: lapply(paths, test_file, env = env, reporter = current_reporter,
     start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
     where 33: force(code)
     where 34: doWithOneRestart(return(expr), restart)
     where 35: withOneRestart(expr, restarts[[1L]])
     where 36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     where 37: with_reporter(reporter = current_reporter, results <- lapply(paths,
     test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE,
     load_helpers = FALSE, wrap = wrap))
     where 38: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 39: test_dir(path = test_path, reporter = reporter, env = env, filter = filter,
     ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,
     wrap = wrap)
     where 40: test_package_dir(package = package, test_path = test_path, filter = filter,
     reporter = reporter, ..., stop_on_failure = stop_on_failure,
     stop_on_warning = stop_on_warning, wrap = wrap)
     where 41: test_check("classiFunc")
    
     --- value of length: 2 type: logical ---
     [1] FALSE FALSE
     --- function from context ---
     function (classes, fdata, grid = 1:ncol(fdata), knn = 1L, metric = "L2",
     nderiv = 0L, derived = FALSE, deriv.method = "base.diff",
     custom.metric = function(x, y, ...) {
     return(sqrt(sum((x - y)^2)))
     }, ...)
     {
     if (class(fdata) == "data.frame")
     fdata = as.matrix(fdata)
     assert_numeric(fdata)
     assertClass(fdata, "matrix")
     if (is.numeric(classes))
     classes = factor(classes)
     assertFactor(classes, any.missing = FALSE, len = nrow(fdata))
     assertNumeric(grid, any.missing = FALSE, len = ncol(fdata))
     assertIntegerish(knn, lower = 1L, upper = nrow(fdata), len = 1)
     assertChoice(metric, choices = metricChoices())
     assertIntegerish(nderiv, lower = 0L)
     assertFlag(derived)
     assertChoice(deriv.method, c("base.diff", "fda.deriv.fd"))
     evenly.spaced = isTRUE(all.equal(grid, seq(grid[1], grid[length(grid)],
     length.out = length(grid)), check.attributes = FALSE))
     no.missing = !anyMissing(fdata)
     if (!no.missing) {
     warning("There are missing values in fdata. They will be filled using a spline representation!")
     }
     this.fdataTransform = fdataTransform(grid = grid, nderiv = nderiv,
     derived = derived, evenly.spaced = evenly.spaced, no.missing = no.missing,
     deriv.method = deriv.method, ...)
     proc.fdata = this.fdataTransform(fdata)
     if (metric != "custom.metric")
     custom.metric = character(0)
     ret = list(classes = classes, fdata = fdata, proc.fdata = proc.fdata,
     grid = grid, knn = knn, metric = metric, custom.metric = custom.metric,
     nderiv = nderiv, this.fdataTransform = this.fdataTransform,
     call = as.list(match.call(expand.dots = FALSE)))
     class(ret) = "classiKnn"
     return(ret)
     }
     <bytecode: 0x7259eb0>
     <environment: namespace:classiFunc>
     --- function search by body ---
     Function classiKnn in namespace classiFunc has this body.
     ----------- END OF FAILURE REPORT --------------
     ── 6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22) ──────
     the condition has length > 1
     Backtrace:
     1. classiFunc::classiKnn(c(1, 1, 2, 2, 1), fdata = trn, knn = 1L)
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 34 | SKIPPED: 0 | WARNINGS: 784 | FAILED: 6 ]
     1. Error: classiKernel works for different Kernels (@test_classiKernel.R#34)
     2. Error: classiKernel works for DTI data set (contains missing values) (@test_classiKernel.R#65)
     3. Error: classiKnn works for phoneme data set from fda.usc package (@test_classiKnn.R#35)
     4. Error: classiKnn works for DTI data set (contains missing values) (@test_classiKnn.R#103)
     5. Error: classiKnn works for growth data set (contains irregular grid) (@test_classiKnn.R#132)
     6. Error: Works with kernel / knn (@test_parallelComputeDistMat.R#22)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-gcc

Version: 0.1.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [34s/41s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(classiFunc)
     >
     > test_check("classiFunc")
     ── 1. Failure: computeDistMat works rucrdtw metrics (@test_computeDistMat.R#100)
     all(as.vector(dist1) <= as.vector(dist3)) isn't true.
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 54 | SKIPPED: 0 | WARNINGS: 780 | FAILED: 1 ]
     1. Failure: computeDistMat works rucrdtw metrics (@test_computeDistMat.R#100)
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-patched-solaris-x86