Last updated on 2026-09-03 09:53:40 CEST.
| Flavor | Version | Tinstall | Tcheck | Ttotal | Status | Flags |
|---|---|---|---|---|---|---|
| r-devel-linux-x86_64-debian-clang | 1.10.2 | 55.37 | 58.07 | 113.44 | OK | |
| r-devel-linux-x86_64-debian-gcc | 1.10.2 | 47.53 | 41.50 | 89.03 | OK | |
| r-devel-linux-x86_64-fedora-clang | 1.10.2 | 16.00 | 33.60 | 49.60 | ERROR | |
| r-devel-linux-x86_64-fedora-gcc | 1.10.2 | 42.00 | 41.37 | 83.37 | OK | |
| r-devel-windows-x86_64 | 1.10.2 | 222.00 | 175.00 | 397.00 | OK | |
| r-patched-linux-x86_64 | 1.10.2 | 58.00 | 50.67 | 108.67 | OK | |
| r-release-linux-x86_64 | 1.10.2 | 60.23 | 48.11 | 108.34 | OK | |
| r-release-macos-arm64 | 1.10.2 | 20.00 | 46.00 | 66.00 | OK | |
| r-release-macos-x86_64 | 1.10.2 | 47.00 | 104.00 | 151.00 | OK | |
| r-release-windows-x86_64 | 1.10.2 | 231.00 | 112.00 | 343.00 | OK | |
| r-oldrel-macos-arm64 | 1.10.2 | 17.00 | 64.00 | 81.00 | OK | |
| r-oldrel-macos-x86_64 | 1.10.2 | 46.00 | 113.00 | 159.00 | OK | |
| r-oldrel-windows-x86_64 | 1.10.2 | 262.00 | 129.00 | 391.00 | OK |
Version: 1.10.2
Check: examples
Result: ERROR
Running examples in ‘nanonext-Ex.R’ failed
The error most likely occurred in:
> ### Name: tls_config
> ### Title: Create TLS Configuration
> ### Aliases: tls_config
>
> ### ** Examples
>
> tls <- tls_config()
Error in tls_config() : 9 | Not supported
Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang
Version: 1.10.2
Check: tests
Result: ERROR
Running ‘tests.R’
Running the tests in ‘tests/tests.R’ failed.
Complete output:
> # minitest - a minimal testing framework v0.0.5 --------------------------------
> test_library <- function(package) library(package = package, character.only = TRUE)
> test_true <- function(x) invisible(isTRUE(x) || {print(x); stop("the above was returned instead of TRUE")})
> test_false <- function(x) invisible(isFALSE(x) || {print(x); stop("the above was returned instead of FALSE")})
> test_null <- function(x) invisible(is.null(x) || {print(x); stop("the above was returned instead of NULL")})
> test_notnull <- function(x) invisible(!is.null(x) || stop("returns NULL when expected to be not NULL"))
> test_zero <- function(x) invisible(x == 0L || {print(x); stop("the above was returned instead of 0L")})
> test_type <- function(type, x) invisible(typeof(x) == type || {stop("object of type '", typeof(x), "' was returned instead of '", type, "'")})
> test_class <- function(class, x) invisible(inherits(x, class) || {stop("object of class '", paste(class(x), collapse = ", "), "' was returned instead of '", class, "'")})
> test_equal <- function(a, b) invisible(a == b || {print(a); print(b); stop("the above expressions were not equal")})
> test_identical <- function(a, b) invisible(identical(a, b) || {print(a); print(b); stop("the above expressions were not identical")})
> test_print <- function(x) invisible(is.character(capture.output(print(x))) || stop("print output of expression cannot be captured as a character value"))
> test_error <- function(x, containing = "") invisible(inherits(x <- tryCatch(x, error = identity), "error") && grepl(containing, x[["message"]], fixed = TRUE) || stop("Expected error message containing: ", containing, "\nActual error message: ", x[["message"]]))
> NOT_CRAN <- Sys.getenv("NOT_CRAN") == "true"
> # ------------------------------------------------------------------------------
>
> test_library("nanonext")
> nng_version()
[1] "1.12.2" "Mbed TLS 3.6.5"
>
> later <- requireNamespace("later", quietly = TRUE)
> promises <- requireNamespace("promises", quietly = TRUE)
>
> test_class("nanoObject", n <- nano("req", listen = "inproc://nanonext", autostart = FALSE))
> test_class("nanoObject", n1 <- nano("rep", dial = "inproc://nanonext", autostart = FALSE))
> test_true(is_nano(n))
> test_class("nanoSocket", n$socket)
> test_class("nano", n$socket)
> n$newmethod <- "doesnotwork"
> test_null(n$newmethod)
> test_type("integer", attr(n$socket, "id"))
> test_equal(n$socket$state, "opened")
> test_equal(n$socket$protocol, "req")
> test_equal(n$send("not ready", mode = "serial"), 8L)
> test_equal(n$recv(), 11L)
> test_class("nano", n$opt("recv-size-max", 8192))
> test_equal(n$opt("recv-size-max"), 8192L)
> test_class("nano", n$opt("recv-buffer", 8L))
> test_equal(n$opt("recv-buffer"), 8L)
> test_error(opt(n$socket, "recv-buffer") <- -1, "Incorrect type")
> test_class("nano", n$opt("req:resend-time", 0L))
> test_class("nano", n$opt("socket-name", "nano"))
> test_equal(n$opt("socket-name"), "nano")
> test_error(n$opt("socket-name", NULL), "argument")
> test_print(n$listener[[1]])
> test_class("nanoListener", n$listener[[1]])
> test_equal(n$listener[[1]]$url, "inproc://nanonext")
> test_equal(n$listener[[1]]$state, "not started")
> test_class("nano", n$listener_opt("recv-size-max", 1024)[[1L]])
> test_equal(n$listener_opt("recv-size-max")[[1L]], 1024L)
> test_error(n$listener_opt("false", 100), "supported")
> test_error(n$listener_opt("false"), "supported")
> test_error(n$listener_opt("false", "false"), "supported")
> test_error(n$listener_opt("false", NULL), "supported")
> test_error(n$listener_opt("false", TRUE), "supported")
> test_error(n$listener_opt("false", list()), "type")
> test_zero(n$listener_start())
> test_equal(n$listener[[1]]$state, "started")
> test_print(n1$dialer[[1]])
> test_class("nanoDialer", n1$dialer[[1]])
> test_equal(n1$dialer[[1]]$url, "inproc://nanonext")
> test_equal(n1$dialer[[1]]$state, "not started")
> test_class("nano", n1$dialer_opt("reconnect-time-min", 1000)[[1L]])
> test_equal(n1$dialer_opt("reconnect-time-min")[[1L]], 1000L)
> test_class("nano", n1$dialer_opt("recv-size-max", 8192)[[1L]])
> test_equal(n1$dialer_opt("recv-size-max")[[1L]], 8192L)
> test_error(n1$dialer_opt("false", 100), "supported")
> test_error(n1$dialer_opt("false"), "supported")
> test_error(n1$dialer_opt("false", "false"), "supported")
> test_error(n1$dialer_opt("false", NULL), "supported")
> test_error(n1$dialer_opt("false", TRUE), "supported")
> test_error(n1$dialer_opt("false", list()), "type")
> test_zero(n1$dialer_start())
> test_equal(n1$dialer[[1]]$state, "started")
>
> test_error(n$send(list(), mode = "raw"), "atomic vector type")
> test_error(n$recv(mode = "none"), "mode")
> test_error(n$recv(mode = "int"), "mode")
> test_error(n$recv(mode = "logica"), "mode")
> test_error(n$recv(mode = "charact"), "mode")
> test_error(n$recv(mode = "positrons"), "mode")
> test_true(is_aio(raio <- recv_aio(n$socket, timeout = 1L, cv = substitute())))
> test_print(raio)
> test_class("errorValue", call_aio(raio)$data)
> test_class("errorValue", raio$data)
> test_zero(pipe_id(raio))
> r <- n$send(data.frame(), block = FALSE)
> if (r == 8L) r <- n$send(data.frame(), block = 500L)
> test_zero(r)
> r <- n1$recv(block = FALSE)
> if (is_error_value(r)) r <- n1$recv(block = 500)
> test_class("data.frame", r)
> test_zero(n1$send(c("test", "", "spec"), mode = "raw", block = 500))
> test_identical(n$recv("character", block = 500), c("test", "", "spec"))
> test_zero(n$send(c("", "", "", "x"), mode = "raw", block = 500))
> test_identical(n1$recv("character", block = 500), c("", "", "", "x"))
> test_zero(n1$send(c("keep", "", ""), mode = "raw", block = 500))
> test_identical(n$recv("character", block = 500), c("keep", "", ""))
> test_zero(n$send(1:5, mode = "raw"))
> test_equal(length(n1$recv("integer", block = 500)), 5L)
> test_true(is_aio(saio <- n1$send_aio(paste(replicate(5, random(1e3L)), collapse = ""), mode = 1L, timeout = 900)))
> test_print(saio)
> if (later) test_null(.keep(saio, new.env()))
> test_class("sendAio", call_aio(saio))
> test_zero(saio$result)
> test_error(n$send("wrong mode", mode = "none"), "mode")
> test_error(n$send("wrong mode", mode = "ser"), "mode")
> test_error(n$send("wrong mode", mode = "rawial"), "mode")
> test_class("recvAio", raio <- n$recv_aio(timeout = 500))
> test_print(raio)
> test_equal(nchar(call_aio(raio)[["value"]]), 10000L)
> test_type("integer", pipe_id(raio))
> raio$newfield <- "doesnotwork"
> test_null(raio$newfield)
> test_class("sendAio", saio <- n$send_aio(c(1.1, 2.2), mode = "raw", timeout = 500))
> saio$newfield <- "doesnotwork"
> test_null(saio$newfield)
> test_type("logical", unresolved(saio))
> test_type("logical", .unresolved(saio))
> test_class("recvAio", msg <- n1$recv_aio(mode = "numeric", timeout = 500))
> test_identical(call_aio(msg), msg)
> test_class("recvAio", msg <- n1$recv_aio(mode = "complex", timeout = 500))
> test_null(stop_aio(msg))
> test_null(stop_aio(n))
> test_false(stop_request(n))
> test_identical(call_aio(msg), msg)
> test_class("errorValue", msg$data)
> test_identical(call_aio(n), n)
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = 1L, timeout = 500))
> test_true(is_nul_byte(suppressWarnings(call_aio_(rraio)$data)))
> test_class("sendAio", sraio <- n$send_aio(as.raw(1L), mode = 2L, timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "raw", timeout = 500))
> test_type("raw", call_aio(rraio)$data)
> test_class("sendAio", sraio <- n$send_aio(c(1+2i, 4+3i), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "complex", timeout = 500))
> test_type("complex", call_aio(rraio)$data)
> test_class("sendAio", sraio <- n$send_aio(5, mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "double", timeout = 500))
> test_type("double", call_aio(rraio)$data)
> test_class("sendAio", sraio <- n$send_aio(c(1, 2), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "numeric", timeout = 500))
> test_true(is.numeric(call_aio(rraio)$data))
> test_class("sendAio", sraio <- n$send_aio(c(1L, 2L, 3L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "integer", timeout = 500))
> test_type("integer", call_aio(rraio)$data)
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "double", timeout = 500))
> test_type("raw", suppressWarnings(call_aio(rraio)$data))
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "integer", timeout = 500))
> test_type("raw", suppressWarnings(call_aio(rraio)$data))
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "logical", timeout = 500))
> test_type("raw", suppressWarnings(collect_aio(rraio)))
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "numeric", timeout = 500))
> test_type("raw", suppressWarnings(rraio[]))
> test_class("sendAio", sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
> test_class("recvAio", rraio <- n1$recv_aio(mode = "complex", timeout = 500))
> test_type("raw", suppressWarnings(collect_aio_(rraio)))
> rcv <- cv()
> test_equal(race_aio(list(rraio), rcv), 1L)
> test_equal(race_aio(list(sraio, rraio), rcv), 1L)
> test_equal(race_aio(list(rraio), NULL), 1L)
> test_equal(race_aio(list(rraio), "invalid"), 1L)
> rtest <- recv_aio(n1$socket, timeout = 100, cv = rcv)
> test_equal(race_aio(list(rtest), rcv), 1L)
> test_error(opt(rraio[["aio"]], "false") <- 0L, "valid")
> test_error(subscribe(rraio[["aio"]], "false"), "valid")
> test_error(opt(rraio[["aio"]], "false"), "valid")
> test_error(stat(rraio[["aio"]], "pipes"), "valid")
>
> test_zero(n$dial(url = "inproc://two", autostart = FALSE))
> test_zero(n$dialer_start())
> test_class("nanoDialer", n$dialer[[1L]])
> test_type("double", stat(n$dialer[[1L]], "id"))
> test_zero(n$listen(url = "inproc://three", autostart = FALSE))
> test_zero(n$listener_start())
> test_class("nanoListener", n$listener[[2L]])
> test_type("double", stat(n$listener[[2L]], "id"))
> test_zero(n$dial(url = "inproc://four"))
> test_zero(close(n$listener[[1]]))
> test_equal(suppressWarnings(start(n$listener[[1]])), 12L)
> test_equal(suppressWarnings(close(n$listener[[1]])), 12L)
> test_zero(close(n1$dialer[[1]]))
> test_equal(suppressWarnings(start(n1$dialer[[1]])), 12L)
> test_equal(suppressWarnings(close(n1$dialer[[1]])), 12L)
> test_zero(reap(n$listener[[2]]))
> test_zero(reap(n$dialer[[2]]))
> test_zero(n$close())
> test_zero(n1$close())
> test_equal(suppressWarnings(n1$close()), 7L)
> test_equal(n$socket[["state"]], "closed")
> test_equal(n1$socket[state], "closed")
>
> test_class("conditionVariable", cv <- cv())
> test_print(cv)
> test_false(until(cv, 10L))
> test_false(until(cv, 10))
> test_false(until_(cv, 10L))
> test_false(until_(cv, 10))
> test_false(until_(cv, "test"))
> test_zero(cv_reset(cv))
> test_zero(cv_value(cv))
>
> test_class("nanoObject", req <- nano("req", listen = "inproc://testing"))
> test_class("nanoSocket", rep <- socket("rep", dial = "inproc://testing", listen = "inproc://testing2"))
> test_print(rep)
> test_equal(stat(rep, "dialers"), 1)
> test_equal(stat(rep, "protocol"), "rep")
> test_null(stat(rep, "nonexistentstat"))
> test_type("character", stat(rep, "name"))
> test_equal(stat(rep, "listeners"), 1)
> test_class("nano", req$opt("req:resend-time", 1000))
> test_equal(req$opt("req:resend-time"), 1000L)
> test_error(req$opt("none"), "supported")
> test_type("externalptr", req$context_open())
> test_class("nanoContext", req$context)
> test_class("nano", req$context)
> test_true(is_nano(req$context))
> test_type("integer", req$context$id)
> test_equal(req$context$state, "opened")
> test_equal(req$context$protocol, "req")
> test_class("nano", req$opt("send-timeout", 1000))
> test_equal(req$opt("send-timeout"), 1000L)
> test_error(req$opt("false", 100), "supported")
> test_error(req$opt("false"), "supported")
> test_error(req$opt("false", "false"), "supported")
> test_error(req$opt("false", NULL), "supported")
> test_error(req$opt("false", TRUE), "supported")
> test_error(req$opt("false", list()), "type")
>
> test_class("nanoContext", ctx <- context(rep))
> test_print(ctx)
> test_true(is_error_value(recv(ctx, block = FALSE)))
> test_true(.mark())
> test_class("sendAio", csaio <- req$send_aio(data.frame(), mode = 1L, timeout = 500))
> test_zero(call_aio_(csaio)$result)
> test_class("recvAio", craio <- recv_aio(ctx, mode = 8L, timeout = 500))
> test_type("raw", res <- collect_aio(craio))
> test_type("list", unserialize(res[9:length(res)]))
> test_false(.mark(FALSE))
> test_zero(req$send("context test", mode ="raw", block = 500))
> test_equal(recv(ctx, mode = "string", block = 500), "context test")
> test_type("integer", req$send(data.frame(), mode = "serial", block = 500))
> test_class("recvAio", msg <- recv_aio(ctx, mode = "serial", timeout = 500))
> test_type("logical", .unresolved(msg))
> test_type("logical", unresolved(msg))
> test_class("data.frame", call_aio(msg)$data)
> test_false(unresolved(msg))
> test_zero(req$send(c(TRUE, FALSE, TRUE), mode = 2L, block = 500))
> test_class("recvAio", msg <- recv_aio(ctx, mode = 6L, timeout = 500))
> test_type("logical", msg[])
> test_identical(collect_aio(msg), collect_aio_(msg))
> test_class("sendAio", err <- send_aio(ctx, msg[["data"]], mode = "serial"))
> test_null(stop_aio(err))
> test_class("sendAio", err <- send_aio(ctx, "test"))
> test_class("errorValue", call_aio(err)$result)
> test_class("errorValue", call_aio(list(err))[[1L]][["result"]])
> test_class("errorValue", call_aio_(err)$result)
> test_class("errorValue", call_aio_(list(item = err))[["item"]][["result"]])
> test_class("errorValue", collect_aio(err))
> test_class("errorValue", collect_aio(list(item = err))[["item"]])
> test_class("errorValue", collect_aio_(list(err))[[1L]])
> test_zero(req$send(serialize(NULL, NULL, ascii = TRUE), mode = 2L, block = 500))
> test_null(call_aio(recv_aio(ctx, mode = 1L, timeout = 500))[["value"]])
> test_class("sendAio", saio <- send_aio(ctx, as.raw(1L), mode = 2L, timeout = 500))
> test_identical(req$recv(mode = 8L, block = 500), as.raw(1L))
> test_class("recvAio", rek <- request(req$context, c(1+3i, 4+2i), send_mode = 2L, recv_mode = "complex", timeout = 500))
> test_zero(reply(ctx, execute = identity, recv_mode = 3L, send_mode = "raw", timeout = 500))
> test_type("complex", call_aio(rek)[["data"]])
> test_class("recvAio", rek <- request(req$context, c(1+3i, 4+2i), send_mode = "serial", recv_mode = "serial", timeout = 500))
> test_zero(reply(ctx, execute = identity, recv_mode = 1L, send_mode = 1L, timeout = 500))
> test_type("complex", call_aio(rek)[["data"]])
> test_type("integer", rek[["aio"]])
>
> test_type("list", cfg <- serial_config(class = c("invalid", "custom"), sfunc = list(identity, function(x) raw(1L)), ufunc = list(identity, as.integer)))
> opt(req$socket, "serial") <- cfg
> opt(rep, "serial") <- cfg
> custom <- list(`class<-`(new.env(), "custom"), new.env())
> test_zero(send(req$socket, custom, mode = "serial", block = 500))
> test_type("integer", recv(rep, block = 500)[[1L]])
> custom <- list(`class<-`(new.env(), "unused"), new.env())
> test_zero(send(req$socket, custom, mode = "serial", block = 500))
> test_type("list", recv(rep, block = 500))
> cfg <- serial_config("custom", function(x) as.raw(length(x)), function(x) lapply(seq_len(as.integer(x)), new.env))
> test_type("list", cfg)
> opt(req$socket, "serial") <- cfg
> opt(rep, "serial") <- cfg
> test_zero(send(rep, custom, block = 500))
> test_type("list", recv(req$socket, mode = 1L, block = 500))
> cfg <- serial_config(c("error_env", "string_class"), list(function(x) stop("serialization failue"), function(x) "serialized string"), list(function(x) stop(), function(x) stop()))
> opt(req$socket, "serial") <- cfg
> test_error(send(req$socket, `class<-`(new.env(), "error_env"), block = 500), "serialization failue")
> test_error(send(req$socket, `class<-`(new.env(), "string_class"), block = 500), "string_class")
> opt(req$socket, "serial") <- cfg
> opt(req$socket, "serial") <- list()
> opt(rep, "serial") <- list()
> test_error(serial_config(1L, identity, identity), "must be a character vector")
> test_error(serial_config(c("custom", "custom2"), list(identity), list(identity)), "must all be the same length")
> test_error(serial_config("custom", "func1", "func2"), "must be a function or list of functions")
> test_error(serial_config("custom", identity, "func2"), "must be a function or list of functions")
> test_error(opt(rep, "wrong") <- cfg, "not supported")
> test_error(opt(rep, "serial") <- pairlist(a = 1L), "not supported")
>
> test_class("recvAio", cs <- request(req$context, "test", send_mode = "serial", cv = cv, timeout = 500, id = TRUE))
> test_notnull(cs$data)
> test_type("externalptr", ctxn <- .context(rep))
> test_class("recvAio", cr <- recv_aio(ctxn, mode = 8L, cv = cv, timeout = 500))
> test_type("raw", call_aio(cr)$data)
> test_type("integer", cr$aio)
> test_type("integer", send(ctxn, TRUE, mode = 0L, block = FALSE))
> test_type("externalptr", ctxn <- .context(rep))
> test_class("recvAio", cs <- request(.context(req$socket), data = TRUE, cv = NA, id = TRUE))
> test_notnull(cs$data)
> test_true(recv(ctxn, block = 500))
> test_zero(send(ctxn, TRUE, mode = 1L, block = 500))
> test_class("recvAio", cs <- request(.context(req$socket), data = TRUE, timeout = 5, id = TRUE))
> test_false(stop_request(cs))
> test_zero(reap(ctxn))
> test_equal(reap(ctxn), 7L)
> test_zero(pipe_notify(rep, cv, add = TRUE, flag = TRUE))
> test_zero(pipe_notify(rep, cv, remove = TRUE, flag = tools::SIGCONT))
> test_zero(pipe_notify(req$socket, cv = cv, add = TRUE))
> test_zero(pipe_notify(rep, cv = NULL, add = TRUE, remove = TRUE))
> test_error(request(err, "test", cv = cv), "valid")
> test_error(recv_aio(err, cv = cv, timeout = 500))
> test_error(wait(err), "valid")
> test_error(wait_(err), "valid")
> test_error(until(err, 10), "valid")
> test_error(until_(err, 10), "valid")
> test_error(cv_value(err), "valid")
> test_error(cv_reset(err), "valid")
> test_error(cv_signal(err), "valid")
> test_error(pipe_notify(err, cv), "valid Socket")
> test_error(pipe_notify(rep, err), "valid Condition Variable")
> test_zero(req$context_close())
> test_null(req$context_close)
> test_zero(req$close())
> test_null(req$context)
> rep$dialer <- NULL
> test_type("externalptr", rep$dialer[[1L]])
> test_zero(close(ctx))
> test_equal(suppressWarnings(close(ctx)), 7L)
> test_zero(close(rep))
>
> test_class("nanoObject", pub <- nano("pub", listen = "inproc://ps"))
> test_class("nanoObject", sub <- nano("sub", dial = "inproc://ps", autostart = NA))
> test_zero(cv_reset(cv))
> test_zero(pipe_notify(pub$socket, cv, add = TRUE, remove = TRUE))
> test_class("nano", sub$opt(name = "sub:prefnew", value = FALSE))
> test_false(sub$opt(name = "sub:prefnew"))
> test_error(sub$opt(name = "false", value = 100), "supported")
> test_error(sub$opt(name = "false"), "supported")
> test_error(sub$opt(name = "false", value = list()), "type")
> test_class("nano", sub$subscribe("test"))
> test_class("nano", subscribe(sub$socket, NULL))
> test_class("nano", sub$unsubscribe("test"))
> test_type("externalptr", sub$context_open())
> test_class("nanoContext", sub$context)
> test_class("nano", sub$subscribe(12))
> test_class("nano", sub$unsubscribe(12))
> test_class("nano", sub$subscribe(NULL))
> test_zero(sub$context_close())
> test_null(sub$context)
> test_zero(sub$close())
> test_zero(pub$close())
> test_true(wait(cv))
> test_type("externalptr", cv2 <- cv())
> test_type("externalptr", cv3 <- cv())
> test_type("externalptr", cv %~>% cv2 %~>% cv3)
> test_zero(cv_signal(cv))
> test_equal(cv_value(cv), 1L)
> test_true(wait_(cv3))
> test_type("externalptr", cv %~>% cv3)
> test_error("a" %~>% cv3, "valid Condition Variable")
> test_error(cv3 %~>% "a", "valid Condition Variable")
>
> test_class("nanoObject", surv <- nano(protocol = "surveyor", listen = "inproc://sock1", dial = "inproc://sock2"))
> test_print(surv)
> test_class("nanoObject", resp <- nano(protocol = "respondent", listen = "inproc://sock2", dial = "inproc://sock1"))
> test_zero(pipe_notify(surv$socket, cv, add = TRUE, remove = TRUE, flag = TRUE))
> surv$dialer <- NULL
> test_type("externalptr", surv$dialer[[1L]])
> test_type("externalptr", surv$listener[[1L]])
> test_class("nano", surv$survey_time(50))
> test_zero(surv$send("survey", block = 500))
> test_class("errorValue", surv$recv(block = 200))
> test_type("externalptr", surv$context_open())
> test_type("externalptr", resp$context_open())
> test_class("nano", surv$survey_time(value = 2000))
> test_zero(surv$context_close())
> test_zero(resp$context_close())
> test_zero(surv$close())
> test_zero(resp$close())
> test_false(wait(cv))
> test_class("errorValue", resp$recv())
>
> test_class("nanoObject", poly <- nano(protocol = "poly", listen = "inproc://polytest"))
> test_equal(formals(poly$send)$pipe, 0L)
> test_equal(formals(poly$send_aio)$pipe, 0L)
> test_zero(poly$close())
>
> test_zero(cv_reset(cv))
> test_class("nanoSocket", poly <- socket(protocol = "poly"))
> test_class("nanoSocket", poly1 <- socket(protocol = "poly"))
> test_class("nanoSocket", poly2 <- socket(protocol = "poly"))
> test_class("nanoMonitor", m <- monitor(poly, cv))
> test_print(m)
> test_zero(listen(poly))
> test_null(read_monitor(m))
> test_class("sendAio", send_aio(poly, "one", timeout = 50))
> invisible(gc())
> test_null(msleep(55))
> test_zero(dial(poly1))
> test_zero(dial(poly2))
> test_true(wait(cv))
> test_true(wait(cv))
> test_equal(length(pipes <- read_monitor(m)), 2L)
> test_zero(send_aio(poly, "one", timeout = 500, pipe = pipes[1L])[])
> test_zero(send(poly, "two", block = 500, pipe = pipes[2L]))
> test_type("integer", send(poly, "two", block = FALSE, pipe = pipes[2L]))
> test_type("character", recv(poly1, block = 500))
> test_type("character", recv(poly2, block = 500))
> while (!is_error_value(recv(poly1, block = 100))) invisible()
> while (!is_error_value(recv(poly2, block = 100))) invisible()
> test_zero(reap(poly2))
> test_zero(reap(poly1))
> test_true(wait(cv))
> test_type("integer", read_monitor(m))
> test_error(read_monitor(poly), "valid Monitor")
> test_error(monitor("socket", "cv"), "valid Socket")
> test_error(monitor(poly, "cv"), "valid Condition Variable")
> test_zero(reap(poly))
>
> test_class("nanoSocket", bus <- socket(protocol = "bus"))
> test_class("nanoSocket", push <- socket(protocol = "push"))
> test_class("nanoSocket", pull <- socket(protocol = "pull"))
> test_class("nanoSocket", pair <- socket(protocol = "pair"))
> test_error(socket("nonsense"), "should be one of")
> test_class("nano", bus)
> test_error(context(bus), "Not supported")
> test_error(context(push), "Not supported")
> test_error(context(pull), "Not supported")
> test_error(context(pair), "Not supported")
> test_equal(suppressWarnings(listen(bus, url = "test", fail = "warn")), 3L)
> test_error(listen(bus, url = "test", fail = "error"), "argument")
> test_equal(listen(bus, url = "test", fail = "none"), 3L)
> test_equal(suppressWarnings(dial(bus, url = "test", fail = 1L)), 3L)
> test_error(dial(bus, url = "test", fail = 2L), "argument")
> test_equal(dial(bus, url = "test", fail = 3L), 3L)
> test_error(listen(bus, url = "test", fail = "xyz"), "fail")
> test_error(listen(bus, url = "test", fail = "wxyz"), "fail")
> test_error(listen(bus, url = "test", fail = "abcde"), "fail")
> test_error(subscribe(bus, "topic"), "supported")
> test_error(listen(bus, url = "tls+tcp://localhost/:0", tls = "wrong"), "valid TLS")
> test_error(dial(bus, url = "tls+tcp://localhost/:0", tls = "wrong"), "valid TLS")
> test_zero(close(bus))
> test_equal(suppressWarnings(close(bus)), 7L)
> test_null(stat(bus, "pipes"))
> test_zero(close(push))
> test_zero(close(pull))
> test_zero(reap(pair))
>
> test_class("nanoSocket", rs <- socket("pair", raw = TRUE))
> test_zero(close(rs))
>
> test_error(socket(protocol = "newprotocol"), "protocol")
> test_error(socket(dial = "test"), "argument")
> test_error(socket(listen = "test"), "argument")
>
> test_type("list", ncurl("http://www.cam.ac.uk/"))
> test_type("list", res <- ncurl("http://www.cam.ac.uk/", follow = FALSE, response = TRUE))
> if (res$status == 301L) test_true(length(res$headers) > 1L)
> test_type("list", ncurl("http://www.cam.ac.uk/", follow = TRUE))
panic: pthread_mutex_lock: Invalid argument
This message is indicative of a BUG.
Report this at https://github.com/nanomsg/nng/issues
/lib64/libnng.so.1(+0x55b2) [0x7fb2674b35b2]
/lib64/libnng.so.1(nng_aio_free+0x1a) [0x7fb2674b35fa]
/data/localhost/ripley/R/packages/tests-clang/nanonext.Rcheck/nanonext/libs/nanonext.so(+0x9b50) [0x7fb26c6dbb50]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0x9172c) [0x560b703c972c]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xdbddb) [0x560b70413ddb]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xca1ec) [0x560b704021ec]
/data/localhost/ripley/R/R-clang/bin/exec/R(Rf_eval+0x1a5) [0x560b704019a5]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xe1a79) [0x560b70419a79]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xe0f6b) [0x560b70418f6b]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xca8b7) [0x560b704028b7]
/data/localhost/ripley/R/R-clang/bin/exec/R(Rf_eval+0x5f8) [0x560b70401df8]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xca444) [0x560b70402444]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xddee0) [0x560b70415ee0]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xce619) [0x560b70406619]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xca1ec) [0x560b704021ec]
/data/localhost/ripley/R/R-clang/bin/exec/R(Rf_eval+0x1a5) [0x560b704019a5]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xe1a79) [0x560b70419a79]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xe0f6b) [0x560b70418f6b]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0xca8b7) [0x560b704028b7]
/data/localhost/ripley/R/R-clang/bin/exec/R(Rf_eval+0x5f8) [0x560b70401df8]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0x116f48) [0x560b7044ef48]
/data/localhost/ripley/R/R-clang/bin/exec/R(run_Rmainloop+0xbf) [0x560b70450a4f]
/data/localhost/ripley/R/R-clang/bin/exec/R(+0x118abb) [0x560b70450abb]
/data/localhost/ripley/R/R-clang/bin/exec/R(main+0x18) [0x560b70339db8]
/lib64/libc.so.6(+0x3681) [0x7fb26e90b681]
/lib64/libc.so.6(__libc_start_main+0x88) [0x7fb26e90b798]
/data/localhost/ripley/R/R-clang/bin/exec/R(_start+0x25) [0x560b70339cd5]
Flavor: r-devel-linux-x86_64-fedora-clang