CRAN Package Check Results for Package cecs

Last updated on 2021-05-22 15:49:22 CEST.

Flavor Version Tinstall Tcheck Ttotal Status Flags
r-devel-linux-x86_64-debian-clang 0.2.1 5.75 27.87 33.62 ERROR
r-devel-linux-x86_64-debian-gcc 0.2.1 4.22 22.69 26.91 ERROR
r-devel-linux-x86_64-fedora-clang 0.2.1 56.39 OK
r-devel-linux-x86_64-fedora-gcc 0.2.1 45.98 OK
r-devel-windows-x86_64 0.2.1 19.00 112.00 131.00 OK
r-devel-windows-x86_64-gcc10-UCRT 0.2.1 OK
r-patched-linux-x86_64 0.2.1 5.32 27.78 33.10 ERROR
r-patched-solaris-x86 0.2.1 80.50 OK
r-release-linux-x86_64 0.2.1 4.73 27.68 32.41 ERROR
r-release-macos-x86_64 0.2.1 OK
r-release-windows-ix86+x86_64 0.2.1 19.00 112.00 131.00 OK
r-oldrel-macos-x86_64 0.2.1 OK
r-oldrel-windows-ix86+x86_64 0.2.1 20.00 97.00 117.00 OK

Check Details

Version: 0.2.1
Check: tests
Result: ERROR
     Running 'testthat.R' [7s/8s]
    Running the tests in 'tests/testthat.R' failed.
    Complete output:
     > library(testthat)
     > library(cecs)
     >
     > test_check("cecs")
     Error: Cannot open input file for reading: No such file or directory
    
     *** caught segfault ***
     address 0xc0, cause 'memory not mapped'
    
     Traceback:
     1: cec2014(func, rnorm(dim))
     2: eval_bare(expr, quo_get_env(quo))
     3: quasi_label(enquo(object), arg = "object")
     4: expect_type(cec2014(func, rnorm(dim)), "double")
     5: .f(func = .l[[1L]][[i]], dim = .l[[2L]][[i]], ...)
     6: purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double")})
     7: eval(code, test_env)
     8: eval(code, test_env)
     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)
     10: doTryCatch(return(expr), name, parentenv, handler)
     11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     13: doTryCatch(return(expr), name, parentenv, handler)
     14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     15: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     17: test_code(desc, code, env = parent.frame(), reporter = reporter)
     18: test_that("all benchmark functions from CEC-2014 can be executed", { problem_dim_grid <- expand.grid(func = 1:30, dim = c(10, 20, 30, 50, 100)) purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double") }) })
     19: eval(code, test_env)
     20: eval(code, test_env)
     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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     29: test_code(NULL, exprs, env)
     30: source_file(path, child_env(env), wrap = wrap)
     31: FUN(X[[i]], ...)
     32: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     33: force(code)
     34: doWithOneRestart(return(expr), restart)
     35: withOneRestart(expr, restarts[[1L]])
     36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     37: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     38: test_files(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, wrap = wrap, load_package = load_package)
     39: 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, wrap = wrap, load_package = load_package, parallel = parallel)
     40: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     41: test_check("cecs")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.2.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [6s/9s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(cecs)
     >
     > test_check("cecs")
     Error: Cannot open input file for reading: No such file or directory
    
     *** caught segfault ***
     address 0xc0, cause 'memory not mapped'
    
     Traceback:
     1: cec2014(func, rnorm(dim))
     2: eval_bare(expr, quo_get_env(quo))
     3: quasi_label(enquo(object), arg = "object")
     4: expect_type(cec2014(func, rnorm(dim)), "double")
     5: .f(func = .l[[1L]][[i]], dim = .l[[2L]][[i]], ...)
     6: purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double")})
     7: eval(code, test_env)
     8: eval(code, test_env)
     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)
     10: doTryCatch(return(expr), name, parentenv, handler)
     11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     13: doTryCatch(return(expr), name, parentenv, handler)
     14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     15: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     17: test_code(desc, code, env = parent.frame(), reporter = reporter)
     18: test_that("all benchmark functions from CEC-2014 can be executed", { problem_dim_grid <- expand.grid(func = 1:30, dim = c(10, 20, 30, 50, 100)) purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double") }) })
     19: eval(code, test_env)
     20: eval(code, test_env)
     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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     29: test_code(NULL, exprs, env)
     30: source_file(path, child_env(env), wrap = wrap)
     31: FUN(X[[i]], ...)
     32: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     33: force(code)
     34: doWithOneRestart(return(expr), restart)
     35: withOneRestart(expr, restarts[[1L]])
     36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     37: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     38: test_files(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, wrap = wrap, load_package = load_package)
     39: 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, wrap = wrap, load_package = load_package, parallel = parallel)
     40: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     41: test_check("cecs")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 0.2.1
Check: tests
Result: ERROR
     Running ‘testthat.R’ [7s/9s]
    Running the tests in ‘tests/testthat.R’ failed.
    Complete output:
     > library(testthat)
     > library(cecs)
     >
     > test_check("cecs")
     Error: Cannot open input file for reading: No such file or directory
    
     *** caught segfault ***
     address 0xc0, cause 'memory not mapped'
    
     Traceback:
     1: cec2014(func, rnorm(dim))
     2: eval_bare(expr, quo_get_env(quo))
     3: quasi_label(enquo(object), arg = "object")
     4: expect_type(cec2014(func, rnorm(dim)), "double")
     5: .f(func = .l[[1L]][[i]], dim = .l[[2L]][[i]], ...)
     6: purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double")})
     7: eval(code, test_env)
     8: eval(code, test_env)
     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)
     10: doTryCatch(return(expr), name, parentenv, handler)
     11: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     12: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     13: doTryCatch(return(expr), name, parentenv, handler)
     14: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     15: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     17: test_code(desc, code, env = parent.frame(), reporter = reporter)
     18: test_that("all benchmark functions from CEC-2014 can be executed", { problem_dim_grid <- expand.grid(func = 1:30, dim = c(10, 20, 30, 50, 100)) purrr::pmap(problem_dim_grid, function(func, dim) { expect_type(cec2014(func, rnorm(dim)), "double") }) })
     19: eval(code, test_env)
     20: eval(code, test_env)
     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)
     22: doTryCatch(return(expr), name, parentenv, handler)
     23: tryCatchOne(expr, names, parentenv, handlers[[1L]])
     24: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
     25: doTryCatch(return(expr), name, parentenv, handler)
     26: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), names[nh], parentenv, handlers[[nh]])
     27: tryCatchList(expr, classes, parentenv, handlers)
     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) { })
     29: test_code(NULL, exprs, env)
     30: source_file(path, child_env(env), wrap = wrap)
     31: FUN(X[[i]], ...)
     32: lapply(test_paths, test_one_file, env = env, wrap = wrap)
     33: force(code)
     34: doWithOneRestart(return(expr), restart)
     35: withOneRestart(expr, restarts[[1L]])
     36: withRestarts(testthat_abort_reporter = function() NULL, force(code))
     37: with_reporter(reporters$multi, lapply(test_paths, test_one_file, env = env, wrap = wrap))
     38: test_files(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, wrap = wrap, load_package = load_package)
     39: 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, wrap = wrap, load_package = load_package, parallel = parallel)
     40: test_dir("testthat", package = package, reporter = reporter, ..., load_package = "installed")
     41: test_check("cecs")
     An irrecoverable exception occurred. R is aborting now ...
     Segmentation fault
Flavors: r-patched-linux-x86_64, r-release-linux-x86_64