Running 'testthat.R' [18s/19s]
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: 0xabc02f8>
  <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: 0xabc02f8>
  <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: 0xabc4e68>
  <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: 0xabc4e68>
  <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: 0xabc4e68>
  <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: 0xabc4e68>
  <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