Running ‘tests.R’ [1s/3s]
Running the tests in ‘tests/tests.R’ failed.
Complete output:
  > library(nanonext)
  > nanotest <- function(x) invisible(x || stop("is not TRUE when expected to be TRUE"))
  > nanotestw <- function(x) invisible(suppressWarnings(x) || stop("is not TRUE when expected to be TRUE"))
  > nanotestz <- function(x) invisible(x == 0L || stop("does not equal 0L as expected"))
  > nanotesti <- function(a, b) invisible(identical(a, b) || stop("the arguments are not identical as expected"))
  > nanotestaio <- function(x) invisible(is_aio(x) || stop("is not of class 'recvAio' or 'sendAio' as expected"))
  > nanotestnano <- function(x) invisible(is_nano(x) || stop("does not inherit from class 'nano' as expected"))
  > nanotestn <- function(x) invisible(is.null(x) || stop("is not NULL when expected to be NULL"))
  > nanotestnn <- function(x) invisible(!is.null(x) || stop("is NULL when expected to be not NULL"))
  > nanotestp <- function(x) invisible(is.character(capture.output(print(x))) || stop("print output of expression cannot be captured as a character value"))
  > nanotestxp <- function(x) invisible(typeof(x) == "externalptr" || stop("is not of type 'externalptr' as expected"))
  > nanotesterr <- function(x, e = "")
  +   invisible(grepl(e, tryCatch(x, error = identity)[["message"]], fixed = TRUE) || stop("expected error message '", e, "' not generated"))
  > later <- requireNamespace("later", quietly = TRUE)
  > 
  > nng_version()
  [1] "1.8.0"           "Mbed TLS 2.28.8"
  > nanotestnano(n <- nano("req", listen = "inproc://nanonext", autostart = FALSE))
  > nanotestnano(n1 <- nano("rep", dial = "inproc://nanonext", autostart = FALSE))
  > nanotest(inherits(n, "nanoObject"))
  > nanotest(inherits(n$socket, "nanoSocket"))
  > nanotest(inherits(n$socket, "nano"))
  > nanotestnano(n)
  > n$newmethod <- "doesnotwork"
  > nanotestn(n$newmethod)
  > nanotest(is.integer(attr(n$socket, "id")))
  > nanotest(n$socket$state == "opened")
  > nanotest(n$socket$protocol == "req")
  > nanotest(n$send("not ready", mode = "next") == 8L)
  > nanotest(n$recv() == 11L)
  > nanotestnano(n$opt("recv-size-max", 8192))
  > nanotest(n$opt("recv-size-max") == 8192L)
  > nanotestnano(n$opt("recv-buffer", 8L))
  > nanotestnano(n$opt("req:resend-time", 0L))
  > nanotestnano(n$opt("socket-name", "nano"))
  > nanotest(n$opt("socket-name") == "nano")
  > nanotesterr(n$opt("socket-name", NULL), "argument")
  > nanotestp(n$listener[[1]])
  > nanotest(inherits(n$listener[[1]], "nanoListener"))
  > nanotest(n$listener[[1]]$url == "inproc://nanonext")
  > nanotest(n$listener[[1]]$state == "not started")
  > nanotestnano(n$listener_opt("recv-size-max", 1024)[[1L]])
  > nanotest(n$listener_opt("recv-size-max")[[1L]] == 1024L)
  > nanotesterr(n$listener_opt("false", 100), "supported")
  > nanotesterr(n$listener_opt("false"), "supported")
  > nanotesterr(n$listener_opt("false", "false"), "supported")
  > nanotesterr(n$listener_opt("false", NULL), "supported")
  > nanotesterr(n$listener_opt("false", TRUE), "supported")
  > nanotesterr(n$listener_opt("false", list()), "type")
  > nanotestz(n$listener_start())
  > nanotest(n$listener[[1]]$state == "started")
  > nanotestp(n1$dialer[[1]])
  > nanotest(inherits(n1$dialer[[1]], "nanoDialer"))
  > nanotest(n1$dialer[[1]]$url == "inproc://nanonext")
  > nanotest(n1$dialer[[1]]$state == "not started")
  > nanotestnano(n1$dialer_opt("reconnect-time-min", 1000)[[1L]])
  > nanotest(n1$dialer_opt("reconnect-time-min")[[1L]] == 1000L)
  > nanotestnano(n1$dialer_opt("recv-size-max", 8192)[[1L]])
  > nanotest(n1$dialer_opt("recv-size-max")[[1L]] == 8192L)
  > nanotesterr(n1$dialer_opt("false", 100), "supported")
  > nanotesterr(n1$dialer_opt("false"), "supported")
  > nanotesterr(n1$dialer_opt("false", "false"), "supported")
  > nanotesterr(n1$dialer_opt("false", NULL), "supported")
  > nanotesterr(n1$dialer_opt("false", TRUE), "supported")
  > nanotesterr(n1$dialer_opt("false", list()), "type")
  > nanotestz(n1$dialer_start())
  > nanotest(n1$dialer[[1]]$state == "started")
  > 
  > nanotesterr(n$send(list(), mode = "raw"), "atomic vector type")
  > nanotesterr(n$recv(mode = "none"), "mode")
  > nanotesterr(n$recv(mode = "c"), "mode")
  > nanotestaio(raio <- n1$recv_aio(timeout = 1L))
  > nanotestp(raio)
  > nanotest(is_error_value(call_aio(raio)$data))
  > nanotest(is_error_value(raio$data))
  > nanotestz(n$send(data.frame(), block = FALSE))
  > nanotest(is.data.frame(n1$recv(block = 500)))
  > nanotestz(n1$send(c("test", "", "spec"), mode = "raw", block = 500))
  > nanotesti(n$recv("character", block = 500), c("test", "", "spec"))
  > nanotestz(n$send(1:5, mode = "r"))
  > nanotest(length(n1$recv("int", block = 500)) == 5L)
  > nanotestaio(saio <- n1$send_aio(paste(replicate(5, random(1e3L)), collapse = ""), mode = 3L, timeout = 900))
  > nanotestp(saio)
  > nanotestaio(call_aio(saio))
  > nanotestz(saio$result)
  > nanotesterr(n$send("wrong mode", mode = "none"), "mode")
  > nanotestaio(raio <- n$recv_aio(timeout = 500))
  > nanotestp(raio)
  > nanotest(nchar(call_aio(raio)[["value"]]) == 10000L)
  > raio$newfield <- "doesnotwork"
  > raio[["newfield"]] <- "doesnotwork"
  > nanotestn(raio$newfield)
  > nanotestaio(saio <- n$send_aio(c(1.1, 2.2), mode = "raw", timeout = 500))
  > saio$newfield <- "doesnotwork"
  > saio[["newfield"]] <- "doesnotwork"
  > nanotestn(saio$newfield)
  > nanotest(is.logical(unresolved(saio)))
  > nanotest(is.logical(.unresolved(saio)))
  > nanotestaio(msg <- n1$recv_aio(mode = "numer", timeout = 500))
  > nanotesti(call_aio(msg), msg)
  > nanotestaio(msg <- n1$recv_aio(mode = "complex", timeout = 500))
  > nanotestn(stop_aio(msg))
  > nanotestn(stop_aio(n))
  > nanotesti(call_aio(msg), msg)
  > nanotest(is_error_value(msg$data))
  > nanotesti(call_aio(n), n)
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "r", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = 1L, timeout = 500))
  > nanotest(is_nul_byte(call_aio_(rraio)$data))
  received data could not be unserialized
  > nanotestaio(sraio <- n$send_aio(as.raw(1L), mode = "ra", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "raw", timeout = 500))
  > nanotest(is.raw(call_aio(rraio)$data))
  > nanotestaio(sraio <- n$send_aio(c(1+2i, 4+3i), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "co", timeout = 500))
  > nanotest(is.complex(call_aio(rraio)$data))
  > nanotestaio(sraio <- n$send_aio(5, mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "d", timeout = 500))
  > nanotest(is.double(call_aio(rraio)$data))
  > nanotestaio(sraio <- n$send_aio(c(1, 2), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "n", timeout = 500))
  > nanotest(is.numeric(call_aio(rraio)$data))
  > nanotestaio(sraio <- n$send_aio(c(1L, 2L, 3L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "i", timeout = 500))
  > nanotest(is.integer(call_aio(rraio)$data))
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "double", timeout = 500))
  > nanotest(is.raw(call_aio(rraio)$data))
  received data could not be converted to double
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "int", timeout = 500))
  > nanotest(is.raw(call_aio(rraio)$data))
  received data could not be converted to integer
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "logical", timeout = 500))
  > nanotestw(is.raw(collect_aio(rraio)))
  received data could not be converted to logical
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "numeric", timeout = 500))
  > nanotest(is.raw(rraio[]))
  received data could not be converted to numeric
  > nanotestaio(sraio <- n$send_aio(as.raw(0L), mode = "raw", timeout = 500))
  > nanotestaio(rraio <- n1$recv_aio(mode = "complex", timeout = 500))
  > nanotest(is.raw(collect_aio_(rraio)))
  received data could not be converted to complex
  > nanotesterr(opt(rraio[["aio"]], "false") <- 0L, "valid")
  > nanotesterr(subscribe(rraio[["aio"]], "false"), "valid")
  > nanotesterr(opt(rraio[["aio"]], "false"), "valid")
  > nanotesterr(stat(rraio[["aio"]], "pipes"), "valid")
  > 
  > nanotestz(n$dial(url = "inproc://two", autostart = FALSE))
  > nanotestz(n$dialer_start())
  > nanotest(inherits(n$dialer[[1L]], "nanoDialer"))
  > nanotest(is.double(stat(n$dialer[[1L]], "id")))
  > nanotestz(n$listen(url = "inproc://three", autostart = FALSE))
  > nanotestz(n$listener_start())
  > nanotest(inherits(n$listener[[2L]], "nanoListener"))
  > nanotest(is.double(stat(n$listener[[2L]], "id")))
  > nanotestz(n$dial(url = "inproc://four"))
  > nanotestz(close(n$listener[[1]]))
  > nanotestw(close(n$listener[[1]]) == 12L)
  > nanotestz(close(n1$dialer[[1]]))
  > nanotestw(close(n1$dialer[[1]]) == 12L)
  > nanotestz(reap(n$listener[[2]]))
  > nanotestz(reap(n$dialer[[2]]))
  > nanotestz(n$close())
  > nanotestz(n1$close())
  > nanotestw(n1$close() == 7L)
  > nanotest(n$socket[["state"]] == "closed")
  > nanotest(n1$socket[state] == "closed")
  > 
  > nanotest(inherits(cv <- cv(), "conditionVariable"))
  > nanotestp(cv)
  > nanotestxp(cv2 <- cv())
  > nanotest(!until(cv, 10L))
  > nanotest(!until(cv, 10))
  > nanotest(!until_(cv, 10L))
  > nanotest(!until_(cv, 10))
  > nanotest(!until_(cv, "test"))
  > nanotestz(cv_reset(cv))
  > nanotestz(cv_value(cv))
  > 
  > nanotestnano(req <- nano("req", listen = "inproc://testing"))
  > nanotestnano(rep <- socket("rep", dial = "inproc://testing", listen = "inproc://testing2"))
  > nanotestp(rep)
  > nanotest(stat(rep, "dialers") == 1)
  > nanotest(stat(rep, "protocol") == "rep")
  > nanotestn(stat(rep, "nonexistentstat"))
  > nanotestnano(req$opt("req:resend-time", 1000))
  > nanotest(req$opt("req:resend-time") == 1000L)
  > nanotesterr(req$opt("none"), "supported")
  > nanotestxp(req$context_open())
  > nanotest(inherits(req$context, "nanoContext"))
  > nanotest(inherits(req$context, "nano"))
  > nanotest(is.integer(req$context$id))
  > nanotest(req$context$state == "opened")
  > nanotest(req$context$protocol == "req")
  > nanotestnano(req$opt("send-timeout", 1000))
  > nanotest(req$opt("send-timeout") == 1000L)
  > nanotesterr(req$opt("false", 100), "supported")
  > nanotesterr(req$opt("false"), "supported")
  > nanotesterr(req$opt("false", "false"), "supported")
  > nanotesterr(req$opt("false", NULL), "supported")
  > nanotesterr(req$opt("false", TRUE), "supported")
  > nanotesterr(req$opt("false", list()), "type")
  > nanotestnano(ctx <- context(rep))
  > nanotestp(ctx)
  > nanotestaio(csaio <- req$send_aio(data.frame(), mode = "seria", timeout = 500))
  > nanotestz(call_aio_(csaio)$result)
  > nanotestaio(craio <- recv_aio(ctx, timeout = 500))
  > nanotest(is.list(collect_aio(craio)))
  > nanotestz(req$send("context test", mode ="raw", block = 500))
  > nanotest(recv(ctx, mode = "string", block = 500) == "context test")
  > nanotestnn(req$send(data.frame(), mode = "seri", block = 500))
  > nanotestaio(msg <- recv_aio(ctx, mode = "ser", timeout = 500))
  > nanotest(is.logical(.unresolved(msg)))
  > nanotest(is.logical(unresolved(msg)))
  > nanotest(is.data.frame(call_aio(msg)$data))
  > nanotest(!unresolved(msg))
  > nanotestz(req$send(c(TRUE, FALSE, TRUE), mode = 2L, block = 500))
  > nanotestaio(msg <- recv_aio(ctx, mode = 6L, timeout = 500))
  > nanotest(is.logical(msg[]))
  > nanotesti(collect_aio(msg), collect_aio_(msg))
  > nanotestaio(err <- send_aio(ctx, msg[["data"]], mode = "next"))
  > nanotestn(stop_aio(err))
  > nanotestaio(err <- send_aio(ctx, "test"))
  > nanotest(is_error_value(call_aio(err)$result))
  > nanotest(is_error_value(call_aio(list(err))[[1L]][["result"]]))
  > nanotest(is_error_value(call_aio_(err)$result))
  > nanotest(is_error_value(call_aio_(list(item = err))[["item"]][["result"]]))
  > nanotest(is_error_value(collect_aio(err)))
  > nanotest(is_error_value(collect_aio(list(item = err))[["item"]]))
  > nanotest(is_error_value(collect_aio_(list(err))[[1L]]))
  > nanotestz(req$send(serialize(NULL, NULL, ascii = TRUE), mode = 2L, block = 500))
  > nanotestn(call_aio(recv_aio(ctx, mode = 1L, timeout = 500))[["value"]])
  > nanotestaio(saio <- send_aio(ctx, as.raw(1L), mode = 2L, timeout = 500))
  > nanotesti(req$recv(mode = 8L, block = 500), as.raw(1L))
  > nanotestaio(rek <- request(req$context, c(1+3i, 4+2i), send_mode = 2L, recv_mode = "complex", timeout = 500))
  > nanotestz(reply(ctx, execute = identity, recv_mode = 3L, send_mode = "ra", timeout = 500))
  > nanotest(is.complex(call_aio(rek)[["data"]]))
  > nanotestaio(rek <- request(req$context, c(1+3i, 4+2i), send_mode = "next", recv_mode = "serial", timeout = 500))
  > nanotestz(reply(ctx, execute = identity, recv_mode = 1L, send_mode = 3L, timeout = 500))
  > nanotest(is.complex(call_aio(rek)[["data"]]))
  > 
  > nanotest(is.pairlist(nxt <- next_config(refhook = list(function(x) raw(1L), as.integer), class = "custom", vec = FALSE)))
  > nanotest(length(nxt) == 2L)
  > nanotest(is.function(nxt[[1L]]))
  > custom <- list(`class<-`(new.env(), "custom"), new.env())
  > nanotestz(req$send(custom, mode = 3L, block = 500))
  > nanotest(is.integer(recv(rep, block = 500)[[1L]]))
  > nanotest(is.pairlist(nxt <- next_config(refhook = list(function(x) list(x = as.raw(1L)), function(x) list(x = new.env())), class = "custom", vec = TRUE)))
  > nanotestz(send(rep, custom, mode = 3L, block = 500))
  > nanotest(is.list(req$recv(mode = 1L, block = 500)))
  > nanotesti(next_config(nxt), nxt)
  > nanotesti(next_config(as.pairlist(c("a", "b", "c"))), nxt)
  > nanotest(is.list(next_config(NULL, mark = TRUE)))
  > nanotestn(unlist(next_config()))
  > nanotesterr(next_config(NULL, class = 1L), "must be a character string")
  > 
  > nanotestaio(cs <- request(req$context, "test", send_mode = "next", cv = cv, timeout = 500))
  > if (later) nanotestaio(set_promise_context(cs, environment()))
  > nanotestnn(cs$data)
  > nanotest(typeof(ctxn <- .context(rep)) == "externalptr")
  > nanotestaio(cr <- recv_aio(ctxn, cv = cv, timeout = 500))
  > nanotest(call_aio(cr)$data == "test")
  > nanotest(is.integer(send(ctxn, TRUE, mode = 0L, block = FALSE)))
  > nanotest(typeof(ctxn <- .context(rep)) == "externalptr")
  > nanotestaio(cs <- request(.context(req$socket), data = TRUE, cv = NA))
  > nanotestnn(cs$data)
  > nanotest(recv(ctxn, block = 500))
  > nanotestz(send(ctxn, TRUE, mode = 3L, block = 500))
  > nanotestz(reap(ctxn))
  > nanotest(reap(ctxn) == 7L)
  > nanotestz(pipe_notify(rep, cv, add = TRUE, flag = TRUE))
  > nanotestz(pipe_notify(rep, cv, remove = TRUE, flag = tools::SIGCONT))
  > nanotestz(pipe_notify(req$socket, cv = cv, add = TRUE))
  > nanotestz(pipe_notify(req$socket, cv = cv, cv2 = cv2, remove = TRUE, flag = tools::SIGCONT))
  > nanotesterr(request(err, "test", cv = cv), "valid")
  > nanotesterr(recv_aio(err, cv = cv, timeout = 500))
  > nanotesterr(wait(err), "valid")
  > nanotesterr(wait_(err), "valid")
  > nanotesterr(until(err, 10), "valid")
  > nanotesterr(until_(err, 10), "valid")
  > nanotesterr(cv_value(err), "valid")
  > nanotesterr(cv_reset(err), "valid")
  > nanotesterr(cv_signal(err), "valid")
  > nanotesterr(pipe_notify(err, cv), "valid Socket")
  > nanotesterr(pipe_notify(rep, err), "valid Condition Variable")
  > nanotesterr(pipe_notify(rep, cv, err), "valid Condition Variable")
  > nanotestz(req$context_close())
  > nanotestn(req$context_close)
  > nanotestz(req$close())
  > nanotestn(req$context)
  > rep$dialer <- NULL
  > nanotestxp(rep$dialer[[1L]])
  > nanotestz(close(ctx))
  > nanotestw(close(ctx) == 7L)
  > nanotestz(close(rep))
  > 
  > nanotestnano(pub <- nano("pub", listen = "inproc://ps"))
  > nanotestnano(sub <- nano("sub", dial = "inproc://ps", autostart = NA))
  > nanotestz(cv_reset(cv))
  > nanotestz(cv_reset(cv2))
  > nanotestz(pipe_notify(pub$socket, cv, cv2, add = TRUE, remove = TRUE))
  > nanotestnano(sub$opt(name = "sub:prefnew", value = FALSE))
  > nanotest(!sub$opt(name = "sub:prefnew"))
  > nanotesterr(sub$opt(name = "false", value = 100), "supported")
  > nanotesterr(sub$opt(name = "false"), "supported")
  > nanotesterr(sub$opt(name = "false", value = list()), "type")
  > nanotestnano(sub$subscribe("test"))
  > nanotestnano(subscribe(sub$socket, NULL))
  > nanotestnano(sub$unsubscribe("test"))
  > nanotestxp(sub$context_open())
  > nanotest(inherits(sub$context, "nanoContext"))
  > nanotestnano(sub$subscribe(12))
  > nanotestnano(sub$unsubscribe(12))
  > nanotestnano(sub$subscribe(NULL))
  > nanotestz(sub$context_close())
  > nanotestn(sub$context)
  > nanotestz(sub$close())
  > nanotestz(pub$close())
  > nanotest(wait(cv))
  > nanotest(wait(cv2))
  > nanotestxp(cv3 <- cv())
  > nanotestxp(cv %~>% cv2 %~>% cv3)
  > nanotestz(cv_signal(cv))
  > nanotest(cv_value(cv) == 1L)
  > nanotest(wait_(cv3))
  > nanotestxp(cv %~>% cv3)
  > nanotesterr("a" %~>% cv3, "valid Condition Variable")
  > nanotesterr(cv3 %~>% "a", "valid Condition Variable")
  > 
  > nanotestnano(surv <- nano(protocol = "surveyor", listen = "inproc://sock1", dial = "inproc://sock2"))
  > nanotestp(surv)
  > nanotestnano(resp <- nano(protocol = "respondent", listen = "inproc://sock2", dial = "inproc://sock1"))
  > nanotestz(pipe_notify(surv$socket, cv, cv2, add = TRUE, remove = TRUE, flag = TRUE))
  > surv$dialer <- NULL
  > nanotestxp(surv$dialer[[1L]])
  > nanotestxp(surv$listener[[1L]])
  > nanotestnano(surv$survey_time(5000))
  > nanotestxp(surv$context_open())
  > nanotestxp(resp$context_open())
  > nanotestnano(surv$survey_time(value = 2000))
  > nanotestz(surv$context_close())
  > nanotestz(resp$context_close())
  > nanotestz(surv$close())
  > nanotestz(resp$close())
  > nanotest(!wait(cv))
  > nanotest(!wait(cv2))
  > nanotest(is_error_value(resp$recv()))
  > 
  > nanotest(inherits(bus <- socket(protocol = "bus"), "nanoSocket"))
  > nanotest(inherits(push <- socket(protocol = "push"), "nanoSocket"))
  > nanotest(inherits(pull <- socket(protocol = "pull"), "nanoSocket"))
  > nanotest(inherits(pair <- socket(protocol = "pair"), "nanoSocket"))
  > nanotestnano(bus)
  > nanotestw(listen(bus, url = "test") == 3L)
  > nanotestw(dial(bus, url = "test") == 3L)
  > nanotesterr(listen(bus, url = "tls+tcp://localhost/:0", tls = "wrong"), "valid TLS")
  > nanotesterr(dial(bus, url = "tls+tcp://localhost/:0", tls = "wrong"), "valid TLS")
  > nanotestz(close(bus))
  > nanotestw(close(bus) == 7L)
  > nanotestz(close(push))
  > nanotestz(reap(pull))
  > nanotestz(reap(pair))
  > nanotesterr(socket(protocol = "newprotocol"), "protocol")
  > nanotesterr(socket(dial = "test"), "argument")
  > nanotesterr(socket(listen = "test"), "argument")
  > 
  > nanotestnn(ncurl("http://www.cam.ac.uk/"))
  > nanotestnn(ncurl("http://www.cam.ac.uk/", follow = FALSE, response = "date"))
  > nanotestnn(ncurl("http://www.cam.ac.uk/", follow = TRUE))
  > nanotestnn(ncurl("http://postman-echo.com/post", convert = FALSE, method = "POST", headers = c(`Content-Type` = "text/plain"), data = "test", response = c("Date", "Server"), timeout = 3000))
  > nanotest(is_error_value(ncurl("http")$data))
  > haio <- ncurl_aio("http://trin.cam.ac.uk/")
  > nanotest(length(call_aio(haio)$headers))
  > haio <- ncurl_aio("https://trin.cam.ac.uk/", convert = FALSE, response = "server")
  > nanotestnn(haio$status)
  > nanotest(is.integer(call_aio(haio)$status))
  > put1 <- ncurl_aio("http://postman-echo.com/put", method = "PUT", headers = c(Authorization = "Bearer token"), data = "test", response = c("Date", "server"), timeout = 3000L)
  > nanotestp(put1)
  > nanotest(is.integer(call_aio_(put1)$status))
  > nanotestnn(put1$headers)
  > nanotestnn(put1$data)
  > nanotestn(stop_aio(put1))
  > haio <- ncurl_aio("https://i.i")
  > nanotest(is_error_value(call_aio(haio)$data))
  > nanotestp(haio$data)
  > ncaio <- ncurl_aio("https://shikokuchuo.net/nanonext/reference/figures/logo.png")
  > nanotest(is.raw(call_aio(ncaio)$data) || is_error_value(ncaio$data))
  Error in nanotest(is.raw(call_aio(ncaio)$data) || is_error_value(ncaio$data)) : 
    is not TRUE when expected to be TRUE
  Execution halted