Sync outliers with the rest of the code.
Also:
- return error in some failed init cases, instead of `CURLE_OK`:
1908, 1910, 1913, 2082, 3010
- lib1541: delete unused struct member.
Closes #19515
CURL *curl = curl_easy_init();
if(curl) {
- CURLcode result;
+ CURLcode res;
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_HEADER, 1L);
curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
- result = curl_easy_perform(curl);
- if(CURLE_OK == result) {
- result = curl_easy_getinfo(curl,
- CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
- &remoteFileSizeByte);
- if(result)
+ res = curl_easy_perform(curl);
+ if(CURLE_OK == res) {
+ res = curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
+ &remoteFileSizeByte);
+ if(res)
return -1;
printf("filesize: %" CURL_FORMAT_CURL_OFF_T "\n", remoteFileSizeByte);
}
const char *localpath)
{
FILE *f = NULL;
- CURLcode result = CURLE_GOT_NOTHING;
+ CURLcode res = CURLE_GOT_NOTHING;
curl_off_t remoteFileSizeByte = sftpGetRemoteFileSize(remotepath);
if(remoteFileSizeByte == -1) {
fseek(f, (long)remoteFileSizeByte, SEEK_SET);
#endif
curl_easy_setopt(curl, CURLOPT_APPEND, 1L);
- result = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
fclose(f);
- if(result == CURLE_OK)
+ if(res == CURLE_OK)
return 1;
else {
- fprintf(stderr, "%s\n", curl_easy_strerror(result));
+ fprintf(stderr, "%s\n", curl_easy_strerror(res));
return 0;
}
}
struct read_ctx *ctx = p;
size_t len = nitems * buflen;
size_t left = ctx->blen - ctx->nsent;
- CURLcode result;
+ CURLcode res;
if(!ctx->nsent) {
/* On first call, set the FRAME information to be used (it defaults
* to CURLWS_BINARY otherwise). */
- result = curl_ws_start_frame(ctx->curl, CURLWS_TEXT,
- (curl_off_t)ctx->blen);
- if(result) {
- fprintf(stderr, "error starting frame: %d\n", result);
+ res = curl_ws_start_frame(ctx->curl, CURLWS_TEXT, (curl_off_t)ctx->blen);
+ if(res) {
+ fprintf(stderr, "error starting frame: %d\n", res);
return CURL_READFUNC_ABORT;
}
}
size_t i;
CURLMsg *msg;
int rounds = 0;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
CURLU *cu;
struct curl_slist *resolve = NULL;
char resolve_buf[1024];
cu = curl_url();
if(!cu) {
curl_mfprintf(stderr, "out of memory\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_set(cu, CURLUPART_URL, url, 0)) {
curl_mfprintf(stderr, "not a URL: '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_get(cu, CURLUPART_HOST, &host, 0)) {
curl_mfprintf(stderr, "could not get host of '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_get(cu, CURLUPART_PORT, &port, 0)) {
curl_mfprintf(stderr, "could not get port of '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
memset(&resolve, 0, sizeof(resolve));
curl_easy_setopt(handles[i].curl, CURLOPT_PIPEWAIT, 1L) != CURLE_OK ||
curl_easy_setopt(handles[i].curl, CURLOPT_URL, url) != CURLE_OK) {
curl_mfprintf(stderr, "failed configuring easy handle - bailing out\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
curl_easy_setopt(handles[i].curl, CURLOPT_HTTP_VERSION, http_version);
multi = curl_multi_init();
if(!multi) {
curl_mfprintf(stderr, "curl_multi_init() failed - bailing out\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
if(curl_multi_add_handle(multi, handles[i].curl) != CURLM_OK) {
curl_mfprintf(stderr, "curl_multi_add_handle() failed - bailing out\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
}
curl_mfprintf(stderr, "INFO: multi_perform round %d\n", rounds);
if(curl_multi_perform(multi, &still_running) != CURLM_OK) {
curl_mfprintf(stderr, "curl_multi_perform() failed - bailing out\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
if(!as_expected) {
curl_mfprintf(stderr, "ERROR: handles not in expected state "
"after %d rounds\n", rounds);
- result = (CURLcode)1;
+ res = (CURLcode)1;
}
break;
}
if(curl_multi_poll(multi, NULL, 0, 100, &numfds) != CURLM_OK) {
curl_mfprintf(stderr, "curl_multi_poll() failed - bailing out\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
"resumed=%d, result %d - wtf?\n", i,
handles[i].paused,
handles[i].resumed, msg->data.result);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
}
curl_multi_cleanup(multi);
curl_global_cleanup();
- return result;
+ return res;
}
CURL *curl = NULL;
CURLM *multi;
int transfers = 1; /* we start with one */
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
debug_config.nohex = TRUE;
debug_config.tracetime = FALSE;
multi = curl_multi_init();
if(!multi) {
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl = curl_easy_init();
if(!curl) {
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(setup_h2_serverpush(curl, URL)) {
curl_mfprintf(stderr, "failed\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_global_cleanup();
- return result;
+ return res;
}
CURLMsg *msg;
int msgs_in_queue;
char range[128];
- CURLcode result = (CURLcode)1;
+ CURLcode res = (CURLcode)1;
if(!URL) {
curl_mfprintf(stderr, "need URL as argument\n");
} while(running_handles > 0 || start_count);
curl_mfprintf(stderr, "exiting\n");
- result = CURLE_OK;
+ res = CURLE_OK;
cleanup:
curl_global_cleanup();
- return result;
+ return res;
}
int resumed;
int done;
int checked_ssl;
- CURLcode result;
+ CURLcode res;
};
static size_t transfer_count_d = 1;
size_t max_host_conns = 0;
size_t max_total_conns = 0;
int fresh_connect = 0;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
(void)URL;
switch(ch) {
case 'h':
usage_hx_download(NULL);
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto optcleanup;
case 'a':
abort_paused = 1;
http_version = CURL_HTTP_VERSION_3ONLY;
else {
usage_hx_download("invalid http version");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto optcleanup;
}
break;
}
default:
usage_hx_download("invalid option");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto optcleanup;
}
}
if(test_argc != 1) {
usage_hx_download("not enough arguments");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto optcleanup;
}
url = test_argv[0];
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
curl_mfprintf(stderr, "curl_global_init() failed\n");
- result = (CURLcode)3;
+ res = (CURLcode)3;
goto optcleanup;
}
share = curl_share_init();
if(!share) {
curl_mfprintf(stderr, "error allocating share\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
transfer_d = calloc(transfer_count_d, sizeof(*transfer_d));
if(!transfer_d) {
curl_mfprintf(stderr, "error allocating transfer structs\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
setup_hx_download(t->curl, url, t, http_version, host, share,
use_earlydata, fresh_connect)) {
curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi, t->curl);
t = get_transfer_for_easy_d(easy);
if(t) {
t->done = 1;
- t->result = m->data.result;
+ t->res = m->data.result;
curl_mfprintf(stderr, "[t-%zu] FINISHED with result %d\n",
- t->idx, t->result);
+ t->idx, t->res);
if(use_earlydata) {
curl_off_t sent;
curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent);
setup_hx_download(t->curl, url, t, http_version, host, share,
use_earlydata, fresh_connect)) {
curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi, t->curl);
curl_easy_cleanup(t->curl);
t->curl = NULL;
}
- if(t->result)
- result = t->result;
+ if(t->res)
+ res = t->res;
else /* on success we expect ssl to have been checked */
assert(t->checked_ssl);
}
free(resolve);
- return result;
+ return res;
}
struct curl_slist *host = NULL;
const char *resolve = NULL;
int ch;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
(void)URL;
share = curl_share_init();
if(!share) {
curl_mfprintf(stderr, "error allocating share\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
transfer_u = calloc(transfer_count_u, sizeof(*transfer_u));
if(!transfer_u) {
curl_mfprintf(stderr, "error allocating transfer structs\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
CURL *curl = curl_easy_init();
if(!curl) {
curl_mfprintf(stderr, "failed to init easy handle\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
for(i = 0; i < transfer_count_u; ++i) {
if(setup_hx_upload(t->curl, url, t, http_version, host, share,
use_earlydata, announce_length)) {
curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(!t->curl || setup_hx_upload(t->curl, url, t, http_version, host,
share, use_earlydata, announce_length)) {
curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi, t->curl);
host, share, use_earlydata,
announce_length)) {
curl_mfprintf(stderr, "[t-%zu] FAILED setup\n", i);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
curl_multi_add_handle(multi, t->curl);
curl_slist_free_all(host);
curl_global_cleanup();
- return result;
+ return res;
}
int add_more, waits, ongoing = 0;
char *host = NULL, *port = NULL;
long http_version = CURL_HTTP_VERSION_1_1;
- CURLcode result = (CURLcode)1;
+ CURLcode res = (CURLcode)1;
if(!URL || !libtest_arg2) {
curl_mfprintf(stderr, "need args: URL proto\n");
cu = curl_url();
if(!cu) {
curl_mfprintf(stderr, "out of memory\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_set(cu, CURLUPART_URL, URL, 0)) {
if(!tse_found_tls_session) {
curl_mfprintf(stderr, "CURLINFO_TLS_SSL_PTR not found during run\n");
- result = CURLE_FAILED_INIT;
+ res = CURLE_FAILED_INIT;
goto cleanup;
}
curl_mfprintf(stderr, "exiting\n");
- result = CURLE_OK;
+ res = CURLE_OK;
cleanup:
curl_url_cleanup(cu);
curl_global_cleanup();
- return result;
+ return res;
}
static CURLcode test_cli_upload_pausing(const char *URL)
{
CURL *curl = NULL;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
CURLU *cu;
struct curl_slist *resolve = NULL;
char resolve_buf[1024];
cu = curl_url();
if(!cu) {
curl_mfprintf(stderr, "out of memory\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_set(cu, CURLUPART_URL, url, 0)) {
curl_mfprintf(stderr, "not a URL: '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_get(cu, CURLUPART_HOST, &host, 0)) {
curl_mfprintf(stderr, "could not get host of '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
if(curl_url_get(cu, CURLUPART_PORT, &port, 0)) {
curl_mfprintf(stderr, "could not get port of '%s'\n", url);
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
memset(&resolve, 0, sizeof(resolve));
curl = curl_easy_init();
if(!curl) {
curl_mfprintf(stderr, "out of memory\n");
- result = (CURLcode)1;
+ res = (CURLcode)1;
goto cleanup;
}
/* We want to use our own read function. */
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb) != CURLE_OK ||
curl_easy_setopt(curl, CURLOPT_RESOLVE, resolve) != CURLE_OK) {
curl_mfprintf(stderr, "something unexpected went wrong - bailing out!\n");
- result = (CURLcode)2;
+ res = (CURLcode)2;
goto cleanup;
}
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version);
- result = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
cleanup:
curl_url_cleanup(cu);
curl_global_cleanup();
- return result;
+ return res;
}
static CURLcode test_cli_ws_data(const char *URL)
{
#ifndef CURL_DISABLE_WEBSOCKETS
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
const char *url;
size_t plen_min = 0, plen_max = 0, count = 1;
int ch, model = 2;
}
if(model == 1)
- result = test_ws_data_m1_echo(url, plen_min, plen_max);
+ res = test_ws_data_m1_echo(url, plen_min, plen_max);
else
- result = test_ws_data_m2_echo(url, count, plen_min, plen_max);
+ res = test_ws_data_m2_echo(url, count, plen_min, plen_max);
curl_global_cleanup();
- return result;
+ return res;
#else /* !CURL_DISABLE_WEBSOCKETS */
(void)URL;
{
#ifndef CURL_DISABLE_WEBSOCKETS
CURL *curl;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
const char *payload;
if(!URL || !libtest_arg2) {
curl_easy_setopt(curl, CURLOPT_USERAGENT, "ws-pingpong");
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
- result = curl_easy_perform(curl);
- curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", result);
- if(result == CURLE_OK)
- result = pingpong(curl, payload);
+ res = curl_easy_perform(curl);
+ curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", res);
+ if(res == CURLE_OK)
+ res = pingpong(curl, payload);
/* always cleanup */
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return result;
+ return res;
#else /* !CURL_DISABLE_WEBSOCKETS */
(void)URL;
CURLcode ws_send_ping(CURL *curl, const char *send_payload)
{
size_t sent;
- CURLcode result = curl_ws_send(curl, send_payload, strlen(send_payload),
- &sent, 0, CURLWS_PING);
- curl_mfprintf(stderr, "ws: curl_ws_send returned %u, sent %zu\n",
- result, sent);
- return result;
+ CURLcode res = curl_ws_send(curl, send_payload, strlen(send_payload),
+ &sent, 0, CURLWS_PING);
+ curl_mfprintf(stderr, "ws: curl_ws_send returned %u, sent %zu\n", res, sent);
+ return res;
}
CURLcode ws_recv_pong(CURL *curl, const char *expected_payload)
size_t rlen;
const struct curl_ws_frame *meta;
char buffer[256];
- CURLcode result = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
- if(result) {
+ CURLcode res = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
+ if(res) {
curl_mfprintf(stderr, "ws: curl_ws_recv returned %u, received %zu\n",
- result, rlen);
- return result;
+ res, rlen);
+ return res;
}
if(!(meta->flags & CURLWS_PONG)) {
if(rlen == strlen(expected_payload) &&
!memcmp(expected_payload, buffer, rlen)) {
curl_mfprintf(stderr, "ws: got the same payload back\n");
- return CURLE_OK; /* lib2304 returned 'result' here. Intentional? */
+ return CURLE_OK; /* lib2304 returned 'res' here. Intentional? */
}
curl_mfprintf(stderr, "ws: did NOT get the same payload back\n");
return CURLE_RECV_ERROR;
void ws_close(CURL *curl)
{
size_t sent;
- CURLcode result = curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
- curl_mfprintf(stderr, "ws: curl_ws_send returned %u, sent %zu\n",
- result, sent);
+ CURLcode res = curl_ws_send(curl, "", 0, &sent, 0, CURLWS_CLOSE);
+ curl_mfprintf(stderr, "ws: curl_ws_send returned %u, sent %zu\n", res, sent);
}
#endif /* CURL_DISABLE_WEBSOCKETS */
int main(int argc, const char **argv)
{
const char *URL = "";
- CURLcode result;
+ CURLcode res;
entry_func_t entry_func;
const char *entry_name;
const char *env;
testnum = (int)num;
}
- result = entry_func(URL);
- curl_mfprintf(stderr, "Test ended with result %d\n", result);
+ res = entry_func(URL);
+ curl_mfprintf(stderr, "Test ended with result %d\n", res);
#ifdef _WIN32
/* flush buffers of all streams regardless of mode */
/* Regular program status codes are limited to 0..127 and 126 and 127 have
* special meanings by the shell, so limit a normal return code to 125 */
- return (int)result <= 125 ? (int)result : 125;
+ return (int)res <= 125 ? (int)res : 125;
}
struct testparams {
unsigned int flags; /* ORed flags as above. */
- CURLcode result; /* Code that should be returned by curl_easy_perform(). */
+ CURLcode res; /* Code that should be returned by curl_easy_perform(). */
};
static const struct testparams testparams[] = {
test_setopt(curl, CURLOPT_FAILONERROR, (p->flags & F_FAIL) ? 1L : 0L);
hasbody = 0;
res = curl_easy_perform(curl);
- if(res != p->result) {
+ if(res != p->res) {
curl_mprintf("%zu: bad error code (%d): resume=%s, fail=%s, http416=%s, "
"content-range=%s, expected=%d\n", num, res,
(p->flags & F_RESUME) ? "yes": "no",
(p->flags & F_FAIL) ? "yes": "no",
(p->flags & F_HTTP416) ? "yes": "no",
(p->flags & F_CONTENTRANGE) ? "yes": "no",
- p->result);
+ p->res);
return 1;
}
if(hasbody && (p->flags & F_IGNOREBODY)) {
CURL *curl;
curl_off_t out_len;
size_t hd_line;
- CURLcode result;
+ CURLcode res;
int http_status;
};
struct t1485_transfer_status *st = (struct t1485_transfer_status *)userp;
const char *hd = ptr;
size_t len = size * nmemb;
- CURLcode result;
+ CURLcode res;
(void)fwrite(ptr, size, nmemb, stdout);
++st->hd_line;
curl_off_t clen;
long httpcode = 0;
/* end of a response */
- result = curl_easy_getinfo(st->curl, CURLINFO_RESPONSE_CODE, &httpcode);
+ res = curl_easy_getinfo(st->curl, CURLINFO_RESPONSE_CODE, &httpcode);
curl_mfprintf(stderr, "header_callback, get status: %ld, %d\n",
- httpcode, result);
+ httpcode, res);
if(httpcode < 100 || httpcode >= 1000) {
curl_mfprintf(stderr, "header_callback, invalid status: %ld, %d\n",
- httpcode, result);
+ httpcode, res);
return CURLE_WRITE_ERROR;
}
st->http_status = (int)httpcode;
if(st->http_status >= 200 && st->http_status < 300) {
- result = curl_easy_getinfo(st->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
- &clen);
+ res = curl_easy_getinfo(st->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
+ &clen);
curl_mfprintf(stderr, "header_callback, info Content-Length: "
- "%" CURL_FORMAT_CURL_OFF_T ", %d\n", clen, result);
- if(result) {
- st->result = result;
+ "%" CURL_FORMAT_CURL_OFF_T ", %d\n", clen, res);
+ if(res) {
+ st->res = res;
return CURLE_WRITE_ERROR;
}
if(clen < 0) {
static CURLcode test_lib1523(const char *URL)
{
- CURLcode ret;
+ CURLcode res;
CURL *curl;
char buffer[CURL_ERROR_SIZE];
curl_global_init(CURL_GLOBAL_ALL);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, dload_progress_cb);
- ret = run(curl, 1, 2);
- if(ret)
- curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
+ res = run(curl, 1, 2);
+ if(res)
+ curl_mfprintf(stderr, "error (%d) %s\n", res, buffer);
- ret = run(curl, 12000, 1);
- if(ret != CURLE_OPERATION_TIMEDOUT)
- curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
+ res = run(curl, 12000, 1);
+ if(res != CURLE_OPERATION_TIMEDOUT)
+ curl_mfprintf(stderr, "error (%d) %s\n", res, buffer);
else
- ret = CURLE_OK;
+ res = CURLE_OK;
curl_easy_cleanup(curl);
curl_global_cleanup();
- return ret;
+ return res;
}
CURL *curl;
int hd_count;
int bd_count;
- CURLcode result;
};
#define KN(a) a, #a
static CURLcode test_lib1568(const char *URL)
{
- CURLcode ret = TEST_ERR_MAJOR_BAD;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl;
curl_off_t port;
if(curlx_str_number(&libtest_arg2, &port, 0xffff))
- return ret;
+ return res;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)
- return ret;
+ return res;
curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
curl_easy_setopt(curl, CURLOPT_PORT, (long)port);
- ret = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
curl_global_cleanup();
- return ret;
+ return res;
}
static CURLcode test_lib1908(const char *URL)
{
- CURLcode ret = CURLE_OK;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl;
start_test_timing();
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
curl_easy_setopt(curl, CURLOPT_ALTSVC, libtest_arg2);
- ret = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
- if(!ret) {
+ if(!res) {
/* make a copy and check that this also has alt-svc activated */
CURL *curldupe = curl_easy_duphandle(curl);
if(curldupe) {
- ret = curl_easy_perform(curldupe);
+ res = curl_easy_perform(curldupe);
/* we close the second handle first, which makes it store the alt-svc
file only to get overwritten when the next handle is closed! */
curl_easy_cleanup(curldupe);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return ret;
+ return res;
}
static CURLcode test_lib1910(const char *URL)
{
- CURLcode ret = CURLE_OK;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl;
start_test_timing();
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_USERPWD, "user\nname:pass\nword");
- ret = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return ret;
+ return res;
}
o;
o = curl_easy_option_next(o)) {
if(o->type == CURLOT_STRING) {
- CURLcode result;
+ CURLcode res;
/*
* Whitelist string options that are safe for abuse
*/
/* This is a string. Make sure that passing in a string longer
CURL_MAX_INPUT_LENGTH returns an error */
- result = curl_easy_setopt(curl, o->id, testbuf);
- switch(result) {
+ res = curl_easy_setopt(curl, o->id, testbuf);
+ switch(res) {
case CURLE_BAD_FUNCTION_ARGUMENT: /* the most normal */
case CURLE_UNKNOWN_OPTION: /* left out from the build */
case CURLE_NOT_BUILT_IN: /* not supported */
default:
/* all other return codes are unexpected */
curl_mfprintf(stderr, "curl_easy_setopt(%s...) returned %d\n",
- o->name, result);
+ o->name, res);
error++;
break;
}
static CURLcode test_lib1913(const char *URL)
{
- CURLcode ret = CURLE_OK;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl;
start_test_timing();
if(libtest_arg2)
/* test1914 sets this extra arg */
curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
- ret = curl_easy_perform(curl);
+ res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
- return ret;
+ return res;
}
static CURLcode test_lib2082(const char *URL) /* libprereq */
{
- struct prcs prereq_cb;
- CURLcode ret = CURLE_OK;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl = NULL;
+ struct prcs prereq_cb;
+
prereq_cb.prereq_retcode = CURL_PREREQFUNC_OK;
prereq_cb.ipv6 = 0;
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
}
- ret = curl_easy_perform(curl);
- if(ret) {
+ res = curl_easy_perform(curl);
+ if(res) {
curl_mfprintf(stderr,
"%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
}
curl_easy_cleanup(curl);
curl_global_cleanup();
- return ret;
+ return res;
}
curl_mfprintf(stderr, "\n");
(void)size;
if(buffer[0] == 0x89) {
- CURLcode result;
+ CURLcode res;
curl_mfprintf(stderr, "send back a simple PONG\n");
- result = curl_ws_send(curl, pong, 2, &sent, 0, 0);
- if(result)
+ res = curl_ws_send(curl, pong, 2, &sent, 0, 0);
+ if(res)
nitems = 0;
}
if(nitems != incoming)
size_t rlen;
const struct curl_ws_frame *meta;
char buffer[256];
- CURLcode result = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
- if(result)
- return result;
+ CURLcode res = curl_ws_recv(curl, buffer, sizeof(buffer), &rlen, &meta);
+ if(res)
+ return res;
curl_mfprintf(stderr, "recv_any: got %zu bytes rflags %x\n", rlen,
meta->flags);
static CURLcode test_lib3010(const char *URL)
{
- CURLcode ret = CURLE_OK;
+ CURLcode res = TEST_ERR_MAJOR_BAD;
CURL *curl = NULL;
curl_off_t retry_after;
char *follow_url = NULL;
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, URL);
- ret = curl_easy_perform(curl);
- if(ret) {
+ res = curl_easy_perform(curl);
+ if(res) {
curl_mfprintf(stderr,
"%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
curl_easy_getinfo(curl, CURLINFO_REDIRECT_URL, &follow_url);
curl_easy_getinfo(curl, CURLINFO_RETRY_AFTER, &retry_after);
curl_mprintf("Retry-After %" CURL_FORMAT_CURL_OFF_T "\n", retry_after);
curl_easy_setopt(curl, CURLOPT_URL, follow_url);
- ret = curl_easy_perform(curl);
- if(ret) {
+ res = curl_easy_perform(curl);
+ if(res) {
curl_mfprintf(stderr,
"%s:%d curl_easy_perform() failed with code %d (%s)\n",
- __FILE__, __LINE__, ret, curl_easy_strerror(ret));
+ __FILE__, __LINE__, res, curl_easy_strerror(res));
goto test_cleanup;
}
curl_easy_cleanup(curl);
curl_global_cleanup();
- return ret;
+ return res;
}
struct Ctx {
const char *URL;
CURLSH *share;
- CURLcode result;
+ CURLcode res;
size_t thread_id;
struct curl_slist *contents;
};
}
test_cleanup:
- ctx->result = res;
+ ctx->res = res;
return 0;
}
ctx[i].share = share;
ctx[i].URL = URL;
ctx[i].thread_id = i;
- ctx[i].result = CURLE_OK;
+ ctx[i].res = CURLE_OK;
ctx[i].contents = NULL;
}
execute(share, ctx);
for(i = 0; i < CURL_ARRAYSIZE(ctx); i++) {
- if(ctx[i].result) {
- res = ctx[i].result;
+ if(ctx[i].res) {
+ res = ctx[i].res;
}
else {
struct curl_slist *item = ctx[i].contents;
{
int counter = 1;
struct curltime now = {1, 0};
- CURLcode result;
+ CURLcode res;
int finaltime;
curl_easy_setopt(easy, CURLOPT_LOW_SPEED_LIMIT, speed_limit);
do {
/* fake the current transfer speed */
easy->progress.current_speed = speed;
- result = Curl_speedcheck(easy, now);
- if(result)
+ res = Curl_speedcheck(easy, now);
+ if(res)
break;
/* step the time */
now.tv_sec = ++counter;
0x61, 0x54, 0x4A, 0x2B, 0xB7, 0x6A, 0x12, 0x08, 0xFB,
};
- CURLcode result;
+ CURLcode res;
const char *beg = (const char *)&cert[0];
const char *end = (const char *)&cert[sizeof(cert)];
struct Curl_easy *data;
data = curl_easy_init();
if(data) {
- result = Curl_extract_certinfo(data, 0, beg, end);
+ res = Curl_extract_certinfo(data, 0, beg, end);
- fail_unless(result == CURLE_OK, "Curl_extract_certinfo returned error");
+ fail_unless(res == CURLE_OK, "Curl_extract_certinfo returned error");
/* a poor man's fuzzing of some initial data to make sure nothing bad
happens */
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_ALTSVC)
char outname[256];
CURL *curl;
- CURLcode result;
+ CURLcode res;
struct altsvcinfo *asi = Curl_altsvc_init();
abort_if(!asi, "Curl_altsvc_i");
- result = Curl_altsvc_load(asi, arg);
- if(result) {
- fail_if(result, "Curl_altsvc_load");
+ res = Curl_altsvc_load(asi, arg);
+ if(res) {
+ fail_if(res, "Curl_altsvc_load");
goto fail;
}
curl_global_init(CURL_GLOBAL_ALL);
fail_unless(Curl_llist_count(&asi->list) == 4, "wrong number of entries");
curl_msnprintf(outname, sizeof(outname), "%s-out", arg);
- result = Curl_altsvc_parse(curl, asi, "h2=\"example.com:8080\"\r\n",
- ALPN_h1, "example.org", 8080);
- fail_if(result, "Curl_altsvc_parse() failed!");
+ res = Curl_altsvc_parse(curl, asi, "h2=\"example.com:8080\"\r\n",
+ ALPN_h1, "example.org", 8080);
+ fail_if(res, "Curl_altsvc_parse() failed!");
fail_unless(Curl_llist_count(&asi->list) == 5, "wrong number of entries");
- result = Curl_altsvc_parse(curl, asi, "h3=\":8080\"\r\n",
- ALPN_h1, "2.example.org", 8080);
- fail_if(result, "Curl_altsvc_parse(2) failed!");
+ res = Curl_altsvc_parse(curl, asi, "h3=\":8080\"\r\n",
+ ALPN_h1, "2.example.org", 8080);
+ fail_if(res, "Curl_altsvc_parse(2) failed!");
fail_unless(Curl_llist_count(&asi->list) == 6, "wrong number of entries");
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.com:8080\", "
- "h3=\"yesyes.com:8080\"\r\n",
- ALPN_h1, "3.example.org", 8080);
- fail_if(result, "Curl_altsvc_parse(3) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.com:8080\", "
+ "h3=\"yesyes.com:8080\"\r\n",
+ ALPN_h1, "3.example.org", 8080);
+ fail_if(res, "Curl_altsvc_parse(3) failed!");
/* that one should make two entries */
fail_unless(Curl_llist_count(&asi->list) == 8, "wrong number of entries");
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.com:443\"; ma = 120;\r\n",
- ALPN_h2, "example.org", 80);
- fail_if(result, "Curl_altsvc_parse(4) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.com:443\"; ma = 120;\r\n",
+ ALPN_h2, "example.org", 80);
+ fail_if(res, "Curl_altsvc_parse(4) failed!");
fail_unless(Curl_llist_count(&asi->list) == 9, "wrong number of entries");
/* quoted 'ma' value */
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.net:443\"; ma=\"180\";\r\n",
- ALPN_h2, "example.net", 80);
- fail_if(result, "Curl_altsvc_parse(5) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.net:443\"; ma=\"180\";\r\n",
+ ALPN_h2, "example.net", 80);
+ fail_if(res, "Curl_altsvc_parse(5) failed!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
- result =
- Curl_altsvc_parse(curl, asi,
- "h2=\":443\", h3=\":443\"; "
- "persist = \"1\"; ma = 120;\r\n",
- ALPN_h1, "curl.se", 80);
- fail_if(result, "Curl_altsvc_parse(6) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\":443\", h3=\":443\"; "
+ "persist = \"1\"; ma = 120;\r\n",
+ ALPN_h1, "curl.se", 80);
+ fail_if(res, "Curl_altsvc_parse(6) failed!");
fail_unless(Curl_llist_count(&asi->list) == 12, "wrong number of entries");
/* clear that one again and decrease the counter */
- result = Curl_altsvc_parse(curl, asi, "clear;\r\n",
- ALPN_h1, "curl.se", 80);
- fail_if(result, "Curl_altsvc_parse(7) failed!");
+ res = Curl_altsvc_parse(curl, asi, "clear;\r\n",
+ ALPN_h1, "curl.se", 80);
+ fail_if(res, "Curl_altsvc_parse(7) failed!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
- result =
- Curl_altsvc_parse(curl, asi,
- "h2=\":443\", h3=\":443\"; "
- "persist = \"1\"; ma = 120;\r\n",
- ALPN_h1, "curl.se", 80);
- fail_if(result, "Curl_altsvc_parse(6) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\":443\", h3=\":443\"; "
+ "persist = \"1\"; ma = 120;\r\n",
+ ALPN_h1, "curl.se", 80);
+ fail_if(res, "Curl_altsvc_parse(6) failed!");
fail_unless(Curl_llist_count(&asi->list) == 12, "wrong number of entries");
/* clear - without semicolon */
- result = Curl_altsvc_parse(curl, asi, "clear\r\n",
- ALPN_h1, "curl.se", 80);
- fail_if(result, "Curl_altsvc_parse(7) failed!");
+ res = Curl_altsvc_parse(curl, asi, "clear\r\n",
+ ALPN_h1, "curl.se", 80);
+ fail_if(res, "Curl_altsvc_parse(7) failed!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
/* only a non-existing alpn */
- result = Curl_altsvc_parse(curl, asi,
- "h6=\"example.net:443\"; ma=\"180\";\r\n",
- ALPN_h2, "5.example.net", 80);
- fail_if(result, "Curl_altsvc_parse(8) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h6=\"example.net:443\"; ma=\"180\";\r\n",
+ ALPN_h2, "5.example.net", 80);
+ fail_if(res, "Curl_altsvc_parse(8) failed!");
/* missing quote in alpn host */
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.net:443,; ma=\"180\";\r\n",
- ALPN_h2, "6.example.net", 80);
- fail_if(result, "Curl_altsvc_parse(9) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.net:443,; ma=\"180\";\r\n",
+ ALPN_h2, "6.example.net", 80);
+ fail_if(res, "Curl_altsvc_parse(9) failed!");
/* missing port in host name */
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.net\"; ma=\"180\";\r\n",
- ALPN_h2, "7.example.net", 80);
- fail_if(result, "Curl_altsvc_parse(10) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.net\"; ma=\"180\";\r\n",
+ ALPN_h2, "7.example.net", 80);
+ fail_if(res, "Curl_altsvc_parse(10) failed!");
/* illegal port in host name */
- result = Curl_altsvc_parse(curl, asi,
- "h2=\"example.net:70000\"; ma=\"180\";\r\n",
- ALPN_h2, "8.example.net", 80);
- fail_if(result, "Curl_altsvc_parse(11) failed!");
+ res = Curl_altsvc_parse(curl, asi,
+ "h2=\"example.net:70000\"; ma=\"180\";\r\n",
+ ALPN_h2, "8.example.net", 80);
+ fail_if(res, "Curl_altsvc_parse(11) failed!");
Curl_altsvc_save(curl, asi, outname);
struct test_spec {
const char *input;
const char *exp_output;
- CURLcode exp_result;
+ CURLcode exp_res;
};
static bool do_test(const struct test_spec *spec, size_t i,
struct dynbuf *dbuf)
{
- CURLcode result;
+ CURLcode res;
const char *in = spec->input;
curlx_dyn_reset(dbuf);
- result = Curl_x509_GTime2str(dbuf, in, in + strlen(in));
- if(result != spec->exp_result) {
+ res = Curl_x509_GTime2str(dbuf, in, in + strlen(in));
+ if(res != spec->exp_res) {
curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
- i, spec->exp_result, result);
+ i, spec->exp_res, res);
return FALSE;
}
- else if(!result && strcmp(spec->exp_output, curlx_dyn_ptr(dbuf))) {
+ else if(!res && strcmp(spec->exp_output, curlx_dyn_ptr(dbuf))) {
curl_mfprintf(stderr,
"test %zu: input '%s', expected output '%s', got '%s'\n",
i, in, spec->exp_output, curlx_dyn_ptr(dbuf));
struct test1657_spec {
CURLcode (*setbuf)(const struct test1657_spec *spec, struct dynbuf *buf);
size_t n;
- CURLcode exp_result;
+ CURLcode exp_res;
};
static CURLcode make1657_nested(const struct test1657_spec *spec,
static bool do_test1657(const struct test1657_spec *spec, size_t i,
struct dynbuf *buf)
{
- CURLcode result;
+ CURLcode res;
struct Curl_asn1Element elem;
const char *in;
memset(&elem, 0, sizeof(elem));
curlx_dyn_reset(buf);
- result = spec->setbuf(spec, buf);
- if(result) {
- curl_mfprintf(stderr, "test %zu: error setting buf %d\n", i, result);
+ res = spec->setbuf(spec, buf);
+ if(res) {
+ curl_mfprintf(stderr, "test %zu: error setting buf %d\n", i, res);
return FALSE;
}
in = curlx_dyn_ptr(buf);
- result = Curl_x509_getASN1Element(&elem, in, in + curlx_dyn_len(buf));
- if(result != spec->exp_result) {
+ res = Curl_x509_getASN1Element(&elem, in, in + curlx_dyn_len(buf));
+ if(res != spec->exp_res) {
curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
- i, spec->exp_result, result);
+ i, spec->exp_res, res);
return FALSE;
}
return TRUE;
*/
static char rrbuffer[256];
-static void rrresults(struct Curl_https_rrinfo *rr, CURLcode result)
+static void rrresults(struct Curl_https_rrinfo *rr, CURLcode res)
{
char *p = rrbuffer;
char *pend = rrbuffer + sizeof(rrbuffer);
- curl_msnprintf(rrbuffer, sizeof(rrbuffer), "r:%d|", (int)result);
+ curl_msnprintf(rrbuffer, sizeof(rrbuffer), "r:%d|", (int)res);
p += strlen(rrbuffer);
if(rr) {
}
};
- CURLcode result = CURLE_OUT_OF_MEMORY;
+ CURLcode res = CURLE_OUT_OF_MEMORY;
CURL *easy;
easy = curl_easy_init();
curl_mprintf("test %u: %s\n", i, t[i].name);
- result = doh_resp_decode_httpsrr(easy, t[i].dns, t[i].len, &hrr);
+ res = doh_resp_decode_httpsrr(easy, t[i].dns, t[i].len, &hrr);
/* create an output */
- rrresults(hrr, result);
+ rrresults(hrr, res);
/* is the output the expected? */
if(strcmp(rrbuffer, t[i].expect)) {
const char *host;
const char *chost; /* if non-NULL, use to lookup with */
const char *hdr; /* if NULL, just do the lookup */
- const CURLcode result; /* parse result */
+ const CURLcode res; /* parse result */
};
static const struct testit headers[] = {
{ NULL, NULL, NULL, CURLE_OK }
};
- CURLcode result;
+ CURLcode res;
struct stsentry *e;
struct hsts *h = Curl_hsts_init();
int i;
for(i = 0; headers[i].host ; i++) {
if(headers[i].hdr) {
- result = Curl_hsts_parse(h, headers[i].host, headers[i].hdr);
+ res = Curl_hsts_parse(h, headers[i].host, headers[i].hdr);
- if(result != headers[i].result) {
+ if(res != headers[i].res) {
curl_mfprintf(stderr, "Curl_hsts_parse(%s) failed: %d\n",
- headers[i].hdr, result);
+ headers[i].hdr, res);
unitfail++;
continue;
}
- else if(result) {
- curl_mprintf("Input %u: error %d\n", i, (int) result);
+ else if(res) {
+ curl_mprintf("Input %u: error %d\n", i, (int)res);
continue;
}
}
UNITTEST_BEGIN(t1661_setup(&bufref))
const char *buffer = NULL;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
/**
* testing Curl_bufref_init.
/**
* testing Curl_bufref_memdup
*/
- result = Curl_bufref_memdup(&bufref, "1661", 3);
- abort_unless(result == CURLE_OK, curl_easy_strerror(result));
+ res = Curl_bufref_memdup(&bufref, "1661", 3);
+ abort_unless(res == CURLE_OK, curl_easy_strerror(res));
fail_unless(freecount == 1, "Destructor not called");
fail_unless((const char *)bufref.ptr != buffer, "Returned pointer not set");
buffer = (const char *)Curl_bufref_ptr(&bufref);
int exp_cf6_creations;
timediff_t min_duration_ms;
timediff_t max_duration_ms;
- CURLcode exp_result;
+ CURLcode exp_res;
const char *pref_family;
};
};
struct test_result {
- CURLcode result;
+ CURLcode res;
struct curltime started;
struct curltime ended;
struct ai_family_stats cf4;
struct cf_test_ctx *ctx = NULL;
struct Curl_cfilter *cf = NULL;
timediff_t created_at;
- CURLcode result;
+ CURLcode res;
(void)data;
(void)conn;
ctx = calloc(1, sizeof(*ctx));
if(!ctx) {
- result = CURLE_OUT_OF_MEMORY;
+ res = CURLE_OUT_OF_MEMORY;
goto out;
}
ctx->idx = test_idx++;
ctx->stats->last_created = created_at;
infof(data, "%04dms: cf[%s] created", (int)created_at, ctx->id);
- result = Curl_cf_create(&cf, &cft_test, ctx);
- if(result)
+ res = Curl_cf_create(&cf, &cft_test, ctx);
+ if(res)
goto out;
Curl_expire(data, ctx->fail_delay_ms, EXPIRE_TIMEOUT);
out:
- *pcf = (!result) ? cf : NULL;
- if(result) {
+ *pcf = (!res) ? cf : NULL;
+ if(res) {
free(cf);
free(ctx);
}
- return result;
+ return res;
}
static void check_result(const struct test_case *tc,
duration_ms = curlx_timediff_ms(tr->ended, tr->started);
curl_mfprintf(stderr, "%d: test case took %dms\n", tc->id, (int)duration_ms);
- if(tr->result != tc->exp_result
- && CURLE_OPERATION_TIMEDOUT != tr->result) {
+ if(tr->res != tc->exp_res
+ && CURLE_OPERATION_TIMEDOUT != tr->res) {
/* on CI we encounter the TIMEOUT result, since images get less CPU
* and events are not as sharply timed. */
curl_msprintf(msg, "%d: expected result %d but got %d",
- tc->id, tc->exp_result, tr->result);
+ tc->id, tc->exp_res, tr->res);
fail(msg);
}
if(tr->cf4.creations != tc->exp_cf4_creations) {
tr.cf4.family = "v4";
tr.started = curlx_now();
- tr.result = curl_easy_perform(easy);
+ tr.res = curl_easy_perform(easy);
tr.ended = curlx_now();
curl_easy_setopt(easy, CURLOPT_RESOLVE, NULL);
struct bufq q;
struct bufc_pool pool;
size_t max_len = chunk_size * max_chunks;
- CURLcode result;
+ CURLcode res;
ssize_t i;
size_t n2;
size_t nwritten, nread;
fail_unless(q.spare == NULL, "init: spare not NULL");
fail_unless(Curl_bufq_len(&q) == 0, "init: bufq length != 0");
- result = Curl_bufq_write(&q, test_data, wsize, &n2);
+ res = Curl_bufq_write(&q, test_data, wsize, &n2);
fail_unless(n2 <= wsize, "write: wrong size returned");
- fail_unless(result == CURLE_OK, "write: wrong result returned");
+ fail_unless(res == CURLE_OK, "write: wrong result returned");
/* write empty bufq full */
nwritten = 0;
Curl_bufq_reset(&q);
while(!Curl_bufq_is_full(&q)) {
- result = Curl_bufq_write(&q, test_data, wsize, &n2);
- if(!result) {
+ res = Curl_bufq_write(&q, test_data, wsize, &n2);
+ if(!res) {
nwritten += n2;
}
- else if(result != CURLE_AGAIN) {
- fail_unless(result == CURLE_AGAIN, "write-loop: unexpected result");
+ else if(res != CURLE_AGAIN) {
+ fail_unless(res == CURLE_AGAIN, "write-loop: unexpected result");
break;
}
}
/* read full bufq empty */
nread = 0;
while(!Curl_bufq_is_empty(&q)) {
- result = Curl_bufq_read(&q, test_data, rsize, &n2);
- if(!result) {
+ res = Curl_bufq_read(&q, test_data, rsize, &n2);
+ if(!res) {
nread += n2;
}
- else if(result != CURLE_AGAIN) {
- fail_unless(result == CURLE_AGAIN, "read-loop: unexpected result");
+ else if(res != CURLE_AGAIN) {
+ fail_unless(res == CURLE_AGAIN, "read-loop: unexpected result");
break;
}
}
}
for(i = 0; i < 1000; ++i) {
- result = Curl_bufq_write(&q, test_data, wsize, &n2);
- if(result && result != CURLE_AGAIN) {
- fail_unless(result == CURLE_AGAIN, "rw-loop: unexpected write result");
+ res = Curl_bufq_write(&q, test_data, wsize, &n2);
+ if(res && res != CURLE_AGAIN) {
+ fail_unless(res == CURLE_AGAIN, "rw-loop: unexpected write result");
break;
}
- result = Curl_bufq_read(&q, test_data, rsize, &n2);
- if(result && result != CURLE_AGAIN) {
- fail_unless(result == CURLE_AGAIN, "rw-loop: unexpected read result");
+ res = Curl_bufq_read(&q, test_data, rsize, &n2);
+ if(res && res != CURLE_AGAIN) {
+ fail_unless(res == CURLE_AGAIN, "rw-loop: unexpected read result");
break;
}
}
Curl_bufq_init2(&q, chunk_size, max_chunks, (opts|BUFQ_OPT_SOFT_LIMIT));
nwritten = 0;
while(!Curl_bufq_is_full(&q)) {
- result = Curl_bufq_write(&q, test_data, wsize, &n2);
- if(result || n2 != wsize) {
- fail_unless(!result && n2 == wsize, "write should be complete");
+ res = Curl_bufq_write(&q, test_data, wsize, &n2);
+ if(res || n2 != wsize) {
+ fail_unless(!res && n2 == wsize, "write should be complete");
break;
}
nwritten += n2;
fail_if(TRUE, "write: bufq full but nwritten wrong");
}
/* do one more write on a full bufq, should work */
- result = Curl_bufq_write(&q, test_data, wsize, &n2);
- fail_unless(!result && n2 == wsize, "write should be complete");
+ res = Curl_bufq_write(&q, test_data, wsize, &n2);
+ fail_unless(!res && n2 == wsize, "write should be complete");
nwritten += n2;
/* see that we get all out again */
nread = 0;
while(!Curl_bufq_is_empty(&q)) {
- result = Curl_bufq_read(&q, test_data, rsize, &n2);
- if(result) {
- fail_unless(result, "read-loop: unexpected fail");
+ res = Curl_bufq_read(&q, test_data, rsize, &n2);
+ if(res) {
+ fail_unless(res, "read-loop: unexpected fail");
break;
}
nread += n2;
struct bufq q;
size_t n;
- CURLcode result;
+ CURLcode res;
unsigned char buf[16*1024];
Curl_bufq_init(&q, 8*1024, 12);
- result = Curl_bufq_read(&q, buf, 128, &n);
- fail_unless(result && result == CURLE_AGAIN, "read empty fail");
+ res = Curl_bufq_read(&q, buf, 128, &n);
+ fail_unless(res && res == CURLE_AGAIN, "read empty fail");
Curl_bufq_free(&q);
check_bufq(0, 1024, 4, 128, 128, BUFQ_OPT_NONE);
struct dynhds hds;
struct dynbuf dbuf;
- CURLcode result;
+ CURLcode res;
size_t i;
/* add 1 more header than allowed */
}
fail_unless(Curl_dynhds_count(&hds) == 2, "should hold 2");
/* exceed limit on # of entries */
- result = Curl_dynhds_add(&hds, "test3", 5, "789", 3);
- fail_unless(result, "add should have failed");
+ res = Curl_dynhds_add(&hds, "test3", 5, "789", 3);
+ fail_unless(res, "add should have failed");
fail_unless(Curl_dynhds_count_name(&hds, "test", 4) == 0, "false positive");
fail_unless(Curl_dynhds_count_name(&hds, "test1", 4) == 0, "false positive");
fail_unless(Curl_dynhds_cremove(&hds, "blablabla") == 2, "should");
fail_if(Curl_dynhds_ccontains(&hds, "blablabla"), "should not");
- result = Curl_dynhds_h1_cadd_line(&hds, "blablabla thingies");
- fail_unless(result, "add should have failed");
- if(!result) {
+ res = Curl_dynhds_h1_cadd_line(&hds, "blablabla thingies");
+ fail_unless(res, "add should have failed");
+ if(!res) {
fail_unless(Curl_dynhds_ccount_name(&hds, "bLABlaBlA") == 0, "should");
fail_if(Curl_dynhds_cadd(&hds, "Bla-Bla", "thingies"), "add failed");
Curl_dynhds_free(&hds);
Curl_dynhds_init(&hds, 128, 4*1024);
/* continuation without previous header fails */
- result = Curl_dynhds_h1_cadd_line(&hds, " indented value");
- fail_unless(result, "add should have failed");
+ res = Curl_dynhds_h1_cadd_line(&hds, " indented value");
+ fail_unless(res, "add should have failed");
/* continuation with previous header must succeed */
fail_if(Curl_dynhds_h1_cadd_line(&hds, "ti1: val1"), "add");
const char *expect; /* the returned content */
const char *next; /* what cp points to after the call */
const char *home;
- CURLcode result;
+ CURLcode res;
};
#if defined(CURL_GNUC_DIAG) || defined(__clang__)
for(i = 0; list[i].home; i++) {
char *path;
const char *cp = i == 0 ? cp0 : list[i].cp;
- CURLcode result = Curl_get_pathname(&cp, &path, list[i].home);
+ CURLcode res = Curl_get_pathname(&cp, &path, list[i].home);
curl_mprintf("%u - Curl_get_pathname(\"%s\", ... \"%s\") == %u\n", i,
- list[i].cp, list[i].home, list[i].result);
- if(result != list[i].result) {
- curl_mprintf("... returned %d\n", result);
+ list[i].cp, list[i].home, list[i].res);
+ if(res != list[i].res) {
+ curl_mprintf("... returned %d\n", res);
unitfail++;
}
- if(!result) {
+ if(!res) {
if(cp && strcmp(cp, list[i].next)) {
curl_mprintf("... cp points to '%s', not '%s' as expected \n",
cp, list[i].next);
curl_off_t filesize;
curl_off_t start;
curl_off_t size;
- CURLcode result;
+ CURLcode res;
};
int i;
for(i = 0; list[i].r; i++) {
curl_off_t start;
curl_off_t size;
- CURLcode result;
+ CURLcode res;
curl_mprintf("%u: '%s' (file size: %" FMT_OFF_T ")\n",
i, list[i].r, list[i].filesize);
- result = Curl_ssh_range(curl, list[i].r, list[i].filesize,
- &start, &size);
- if(result != list[i].result) {
- curl_mprintf("... returned %d\n", result);
+ res = Curl_ssh_range(curl, list[i].r, list[i].filesize,
+ &start, &size);
+ if(res != list[i].res) {
+ curl_mprintf("... returned %d\n", res);
unitfail++;
}
- if(!result) {
+ if(!res) {
if(start != list[i].start) {
curl_mprintf("... start (%" FMT_OFF_T ") was not %" FMT_OFF_T " \n",
start, list[i].start);
#endif
size_t i;
- CURLcode result = CURLE_OK;
+ CURLcode res = CURLE_OK;
for(i = 0; i < CURL_ARRAYSIZE(filecontents); i++) {
FILE *fp;
struct dynbuf buf;
curl_mfprintf(stderr, "Test %zd...", i);
switch(i) {
case 0:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\n", line),
"First line failed (1)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE2 NEWLINE\n", line),
+ fail_unless(!res && line && !strcmp("LINE2 NEWLINE\n", line),
"Second line failed (1)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (1)");
break;
case 1:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\n", line),
"First line failed (2)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE2 NONEWLINE\n", line),
+ fail_unless(!res && line && !strcmp("LINE2 NONEWLINE\n", line),
"Second line failed (2)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (2)");
break;
case 2:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\n", line),
"First line failed (3)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not detect max read on EOF (3)");
break;
case 3:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\n", line),
"First line failed (4)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not ignore partial on EOF (4)");
break;
case 4:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\n", line),
"First line failed (5)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not bail out on too long line");
break;
case 5:
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
- fail_unless(!result && line && !strcmp("LINE1\x1aTEST\n", line),
+ fail_unless(!res && line && !strcmp("LINE1\x1aTEST\n", line),
"Missed/Misinterpreted ^Z (6)");
- result = Curl_get_line(&buf, fp, &eof);
+ res = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (6)");
break;
default:
curlx_fclose(fp);
curl_mfprintf(stderr, "OK\n");
}
- return result;
+ return res;
#endif
projects / thirdparty / curl.git / commitdiff
