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 |
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