Package check result: ERROR

Check: whether package can be installed, Result: WARNING
  Found the following significant warnings:
    ../inst/include/mlpack/methods/adaboost/adaboost_impl.hpp:338:19: warning: assigning field to itself [-Wself-assign-field]
  See ‘/home/hornik/tmp/CRAN_special_clang19/mlpack.Rcheck/00install.out’ for details.
  Used C++ compiler: ‘Debian clang version 19.1.0 (1)’

Check: tests, Result: ERROR
    Running ‘testthat.R’ [5s/5s]
  Running the tests in ‘tests/testthat.R’ failed.
  Complete output:
    > library(testthat)
    > library(mlpack)
    
    Attaching package: 'mlpack'
    
    The following object is masked from 'package:stats':
    
        kmeans
    
    The following object is masked from 'package:base':
    
        det
    
    > 
    > test_check("mlpack")
    [FATAL] When passing labels from R to mlpack, labels should be in the range from 1 to the number of classes!
    
    
     *** caught segfault ***
    address (nil), cause 'unknown'
    
    Traceback:
     1: SetParamUCol(p, "ucol_in", to_matrix(ucol_in))
     2: test_r_binding(4, 12, "hello", ucol_in = y)
     3: eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
     4: withCallingHandlers({    code    NULL}, error = function(cnd) {    if (can_entrace(cnd)) {        cnd <- cnd_entrace(cnd)    }    return_from(env, cnd)})
     5: .capture(act$val <- eval_bare(quo_get_expr(.quo), quo_get_env(.quo)),     ...)
     6: quasi_capture(enquo(object), label, capture_error, entrace = TRUE)
     7: expect_error(test_r_binding(4, 12, "hello", ucol_in = y))
     8: eval(code, test_env)
     9: eval(code, test_env)
    10: 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)
    11: doTryCatch(return(expr), name, parentenv, handler)
    12: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    13: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
    14: doTryCatch(return(expr), name, parentenv, handler)
    15: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
    16: tryCatchList(expr, classes, parentenv, handlers)
    17: 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) {    })
    18: test_code(desc, code, env = parent.frame(), default_reporter = local_interactive_reporter())
    19: test_that("TestZeroLabels", {    x <- vector(mode = "integer", 10)    expect_error(test_r_binding(4, 12, "hello", urow_in = x))    y <- matrix(0, 10, 1)    expect_error(test_r_binding(4, 12, "hello", ucol_in = y))})
    20: eval(code, test_env)
    21: eval(code, test_env)
    22: 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)
    23: doTryCatch(return(expr), name, parentenv, handler)
    24: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    25: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
    26: doTryCatch(return(expr), name, parentenv, handler)
    27: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]),     names[nh], parentenv, handlers[[nh]])
    28: tryCatchList(expr, classes, parentenv, handlers)
    29: 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) {    })
    30: test_code(test = NULL, code = exprs, env = env, default_reporter = StopReporter$new())
    31: source_file(path, env = env(env), desc = desc, error_call = error_call)
    32: FUN(X[[i]], ...)
    33: lapply(test_paths, test_one_file, env = env, desc = desc, error_call = error_call)
    34: doTryCatch(return(expr), name, parentenv, handler)
    35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
    36: tryCatchList(expr, classes, parentenv, handlers)
    37: tryCatch(code, testthat_abort_reporter = function(cnd) {    cat(conditionMessage(cnd), "\n")    NULL})
    38: with_reporter(reporters$multi, lapply(test_paths, test_one_file,     env = env, desc = desc, error_call = error_call))
    39: test_files_serial(test_dir = test_dir, test_package = test_package,     test_paths = test_paths, load_helpers = load_helpers, reporter = reporter,     env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,     desc = desc, load_package = load_package, error_call = error_call)
    40: test_files(test_dir = path, test_paths = test_paths, test_package = package,     reporter = reporter, load_helpers = load_helpers, env = env,     stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning,     load_package = load_package, parallel = parallel)
    41: test_dir("testthat", package = package, reporter = reporter,     ..., load_package = "installed")
    42: test_check("mlpack")
    An irrecoverable exception occurred. R is aborting now ...
    Segmentation fault