git-market/curl-curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-04-11 12:01:42 +08:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

tests: rename more CURLcode variables to result

Browse Source 
For consistency.

Also:
- one remaining in `src/tool_writeout.c`.
- replace casting an `int` to `CURLcode`.
- lib758: rename `CURLMcode` `result` to `mresult`.
- move literals to the right side of if expressions.

Follow-up to d0dc6e2ec0 #20426
Follow-up to 56f600ec23

Closes #20432
This commit is contained in:
Viktor Szakats 2026-01-25 18:12:40 +01:00
parent 26c39d8df1
commit 2da1bbca96
No known key found for this signature in database
GPG Key ID: B5ABD165E2AEF201
33 changed files with 307 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/tool_writeout.c
View File

@ -163,8 +163,9 @@ static void certinfo(struct per_transfer *per)
{
if(!per->certinfo) {
struct curl_certinfo *certinfo;
CURLcode res = curl_easy_getinfo(per->curl, CURLINFO_CERTINFO, &certinfo);
per->certinfo = (!res && certinfo) ? certinfo : NULL;
CURLcode result = curl_easy_getinfo(per->curl, CURLINFO_CERTINFO,
&certinfo);
per->certinfo = (!result && certinfo) ? certinfo : NULL;
}
}

10
tests/libtest/cli_tls_session_reuse.c
View File

@ -33,13 +33,13 @@ static size_t write_tse_cb(char *ptr, size_t size, size_t nmemb, void *opaque)
(void)ptr;
if(!tse_found_tls_session) {
struct curl_tlssessioninfo *tlssession;
CURLcode rc;
CURLcode result;
rc = curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tlssession);
if(rc) {
result = curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tlssession);
if(result) {
curl_mfprintf(stderr, "curl_easy_getinfo(CURLINFO_TLS_SSL_PTR) "
"failed: %s\n", curl_easy_strerror(rc));
return rc;
"failed: %s\n", curl_easy_strerror(result));
return result;
}
if(tlssession->backend == CURLSSLBACKEND_NONE) {
curl_mfprintf(stderr, "curl_easy_getinfo(CURLINFO_TLS_SSL_PTR) "

42
tests/libtest/cli_ws_data.c
View File

@ -74,7 +74,7 @@ static CURLcode test_ws_data_m2_echo(const char *url,
size_t plen_max)
{
CURL *curl = NULL;
CURLcode r = CURLE_OK;
CURLcode result = CURLE_OK;
const struct curl_ws_frame *frame;
size_t len;
char *send_buf = NULL, *recv_buf = NULL;
@ -84,7 +84,7 @@ static CURLcode test_ws_data_m2_echo(const char *url,
send_buf = curlx_calloc(1, plen_max + 1);
recv_buf = curlx_calloc(1, plen_max + 1);
if(!send_buf || !recv_buf) {
r = CURLE_OUT_OF_MEMORY;
result = CURLE_OUT_OF_MEMORY;
goto out;
}
for(i = 0; i < plen_max; ++i) {
@ -93,7 +93,7 @@ static CURLcode test_ws_data_m2_echo(const char *url,
curl = curl_easy_init();
if(!curl) {
r = CURLE_OUT_OF_MEMORY;
result = CURLE_OUT_OF_MEMORY;
goto out;
}
@ -103,9 +103,9 @@ static CURLcode test_ws_data_m2_echo(const char *url,
curl_easy_setopt(curl, CURLOPT_USERAGENT, "ws-data");
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
curl_easy_setopt(curl, CURLOPT_CONNECT_ONLY, 2L); /* websocket style */
r = curl_easy_perform(curl);
curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", r);
if(r != CURLE_OK)
result = curl_easy_perform(curl);
curl_mfprintf(stderr, "curl_easy_perform() returned %u\n", result);
if(result != CURLE_OK)
goto out;
for(len = plen_min; len <= plen_max; ++len) {
@ -116,12 +116,12 @@ static CURLcode test_ws_data_m2_echo(const char *url,
while(slen || rlen || scount || rcount) {
sblock = rblock = 1;
if(slen) {
r = curl_ws_send(curl, sbuf, slen, &nwritten, 0, CURLWS_BINARY);
sblock = (r == CURLE_AGAIN);
if(!r || (r == CURLE_AGAIN)) {
result = curl_ws_send(curl, sbuf, slen, &nwritten, 0, CURLWS_BINARY);
sblock = (result == CURLE_AGAIN);
if(!result || (result == CURLE_AGAIN)) {
curl_mfprintf(stderr, "curl_ws_send(len=%zu) -> %d, "
"%zu (%" CURL_FORMAT_CURL_OFF_T "/%zu)\n",
slen, r, nwritten, (curl_off_t)(len - slen), len);
slen, result, nwritten, (curl_off_t)(len - slen), len);
sbuf += nwritten;
slen -= nwritten;
}
@ -136,15 +136,15 @@ static CURLcode test_ws_data_m2_echo(const char *url,
if(rlen) {
size_t max_recv = (64 * 1024);
r = curl_ws_recv(curl, rbuf, (rlen > max_recv) ? max_recv : rlen,
&nread, &frame);
if(!r || (r == CURLE_AGAIN)) {
rblock = (r == CURLE_AGAIN);
result = curl_ws_recv(curl, rbuf, (rlen > max_recv) ? max_recv : rlen,
&nread, &frame);
if(!result || (result == CURLE_AGAIN)) {
rblock = (result == CURLE_AGAIN);
curl_mfprintf(stderr, "curl_ws_recv(len=%zu) -> %d, %zu (%ld/%zu) "
"\n", rlen, r, nread, (long)(len - rlen), len);
if(!r) {
r = test_ws_data_m2_check_recv(frame, len - rlen, nread, len);
if(r)
"\n", rlen, result, nread, (long)(len - rlen), len);
if(!result) {
result = test_ws_data_m2_check_recv(frame, len - rlen, nread, len);
if(result)
goto out;
}
rbuf += nread;
@ -171,20 +171,20 @@ static CURLcode test_ws_data_m2_echo(const char *url,
(const unsigned char *)send_buf, len, FALSE);
debug_dump("", "received:", stderr,
(const unsigned char *)recv_buf, len, FALSE);
r = CURLE_RECV_ERROR;
result = CURLE_RECV_ERROR;
goto out;
}
}
out:
if(curl) {
if(!r)
if(!result)
ws_close(curl);
curl_easy_cleanup(curl);
}
curlx_free(send_buf);
curlx_free(recv_buf);
return r;
return result;
}
struct test_ws_m1_ctx {

2
tests/libtest/lib1156.c
View File

@ -160,7 +160,7 @@ static CURLcode test_lib1156(const char *URL)
curl_global_cleanup();
curl_mprintf("%d\n", status);
return (CURLcode)status;
return status ? TEST_ERR_FAILURE : CURLE_OK;
test_cleanup:

4
tests/libtest/lib1509.c
View File

@ -63,7 +63,7 @@ static CURLcode test_lib1509(const char *URL)
easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L);
code = curl_easy_perform(curl);
if(CURLE_OK != code) {
if(code != CURLE_OK) {
curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed, "
"with code %d (%s)\n",
__FILE__, __LINE__, code, curl_easy_strerror(code));
@ -72,7 +72,7 @@ static CURLcode test_lib1509(const char *URL)
}
code = curl_easy_getinfo(curl, CURLINFO_HEADER_SIZE, &headerSize);
if(CURLE_OK != code) {
if(code != CURLE_OK) {
curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
"with code %d (%s)\n",
__FILE__, __LINE__, code, curl_easy_strerror(code));

4
tests/libtest/lib1597.c
View File

@ -28,7 +28,7 @@
struct pair {
const char *in;
CURLcode *exp;
CURLcode *result_exp;
};
static CURLcode test_lib1597(const char *URL)
@ -95,7 +95,7 @@ static CURLcode test_lib1597(const char *URL)
/* Run the tests. */
for(i = 0; prots[i].in; i++) {
result = curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, prots[i].in);
if(result != *prots[i].exp) {
if(result != *prots[i].result_exp) {
curl_mprintf("unexpectedly '%s' returned %d\n", prots[i].in, result);
break;
}

10
tests/libtest/lib1939.c
View File

@ -35,16 +35,16 @@ static CURLcode test_lib1939(const char *URL)
if(multi) {
curl = curl_easy_init();
if(curl) {
CURLcode c;
CURLcode result;
CURLMcode mresult;
/* Crash only happens when using HTTPS */
c = curl_easy_setopt(curl, CURLOPT_URL, URL);
if(!c)
result = curl_easy_setopt(curl, CURLOPT_URL, URL);
if(!result)
/* Any old HTTP tunneling proxy will do here */
c = curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
result = curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
if(!c) {
if(!result) {
/* We are going to drive the transfer using multi interface here,
because we want to stop during the middle. */

8
tests/libtest/lib2032.c
View File

@ -35,19 +35,19 @@ static size_t callback(char *ptr, size_t size, size_t nmemb, void *data)
ssize_t idx = ((CURL **)data) - ntlm_curls;
curl_socket_t sock;
long longdata;
CURLcode code;
CURLcode result;
const size_t failure = (size && nmemb) ? 0 : 1;
(void)ptr;
ntlm_counter[idx] += (int)(size * nmemb);
/* Get socket being used for this easy handle, otherwise CURL_SOCKET_BAD */
code = curl_easy_getinfo(ntlm_curls[idx], CURLINFO_LASTSOCKET, &longdata);
result = curl_easy_getinfo(ntlm_curls[idx], CURLINFO_LASTSOCKET, &longdata);
if(CURLE_OK != code) {
if(result != CURLE_OK) {
curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
"with code %d (%s)\n",
__FILE__, __LINE__, code, curl_easy_strerror(code));
__FILE__, __LINE__, result, curl_easy_strerror(result));
ntlmcb_res = TEST_ERR_MAJOR_BAD;
return failure;
}

16
tests/libtest/lib3026.c
View File

@ -42,7 +42,7 @@ static CURLcode test_lib3026(const char *URL)
CURLcode results[NUM_THREADS];
HANDLE thread_handles[NUM_THREADS];
unsigned tid_count = NUM_THREADS, i;
CURLcode test_failure = CURLE_OK;
CURLcode result = CURLE_OK;
curl_version_info_data *ver;
(void)URL;
@ -63,7 +63,7 @@ static CURLcode test_lib3026(const char *URL)
"GetLastError 0x%08lx\n",
__FILE__, __LINE__, GetLastError());
tid_count = i;
test_failure = TEST_ERR_MAJOR_BAD;
result = TEST_ERR_MAJOR_BAD;
goto cleanup;
}
thread_handles[i] = th;
@ -77,11 +77,11 @@ cleanup:
curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
"with code %d (%s)\n", __FILE__, __LINE__,
i, results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
result = TEST_ERR_MAJOR_BAD;
}
}
return test_failure;
return result;
}
#elif defined(HAVE_PTHREAD_H)
@ -103,7 +103,7 @@ static CURLcode test_lib3026(const char *URL)
CURLcode results[NUM_THREADS];
pthread_t tids[NUM_THREADS];
unsigned tid_count = NUM_THREADS, i;
CURLcode test_failure = CURLE_OK;
CURLcode result = CURLE_OK;
curl_version_info_data *ver;
(void)URL;
@ -123,7 +123,7 @@ static CURLcode test_lib3026(const char *URL)
curl_mfprintf(stderr, "%s:%d Could not create thread, errno %d\n",
__FILE__, __LINE__, res);
tid_count = i;
test_failure = TEST_ERR_MAJOR_BAD;
result = TEST_ERR_MAJOR_BAD;
goto cleanup;
}
}
@ -135,11 +135,11 @@ cleanup:
curl_mfprintf(stderr, "%s:%d thread[%u]: curl_global_init() failed,"
"with code %d (%s)\n", __FILE__, __LINE__,
i, results[i], curl_easy_strerror(results[i]));
test_failure = TEST_ERR_MAJOR_BAD;
result = TEST_ERR_MAJOR_BAD;
}
}
return test_failure;
return result;
}
#else /* without pthread or Windows, this test does not work */

14
tests/libtest/lib3027.c
View File

@ -25,7 +25,7 @@
static CURLcode test_lib3027(const char *URL)
{
CURLcode ret = CURLE_OK;
CURLcode result = CURLE_OK;
CURL *curl;
start_test_timing();
@ -35,18 +35,18 @@ static CURLcode test_lib3027(const char *URL)
if(curl) {
curl_easy_setopt(curl, CURLOPT_URL, URL);
curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
ret = curl_easy_perform(curl);
if(CURLE_OK == ret) {
result = curl_easy_perform(curl);
if(result == CURLE_OK) {
long filetime;
ret = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
result = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
/* MTDM fails with 550, so filetime should be -1 */
if((CURLE_OK == ret) && (filetime != -1)) {
if((result == CURLE_OK) && (filetime != -1)) {
/* we just need to return something which is not CURLE_OK */
ret = CURLE_UNSUPPORTED_PROTOCOL;
result = CURLE_UNSUPPORTED_PROTOCOL;
}
}
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return ret;
return result;
}

14
tests/libtest/lib512.c
View File

@ -28,11 +28,11 @@
static CURLcode test_lib512(const char *URL)
{
CURLcode code;
CURLcode result;
int rc = 99;
code = curl_global_init(CURL_GLOBAL_ALL);
if(code == CURLE_OK) {
result = curl_global_init(CURL_GLOBAL_ALL);
if(result == CURLE_OK) {
CURL *curl = curl_easy_init();
if(curl) {
CURL *curl2;
@ -43,11 +43,11 @@ static CURLcode test_lib512(const char *URL)
curl2 = curl_easy_duphandle(curl);
if(curl2) {
code = curl_easy_setopt(curl2, CURLOPT_URL, URL);
if(code == CURLE_OK) {
result = curl_easy_setopt(curl2, CURLOPT_URL, URL);
if(result == CURLE_OK) {
code = curl_easy_perform(curl2);
if(code == CURLE_OK)
result = curl_easy_perform(curl2);
if(result == CURLE_OK)
rc = 0;
else
rc = 1;

32
tests/libtest/lib530.c
View File

@ -389,28 +389,28 @@ test_cleanup:
static CURLcode test_lib530(const char *URL)
{
CURLcode rc;
CURLcode result;
/* rerun the same transfer multiple times and make it fail in different
callback calls */
rc = testone(URL, 0, 0); /* no callback fails */
if(rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), rc);
result = testone(URL, 0, 0); /* no callback fails */
if(result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), result);
rc = testone(URL, 1, 0); /* fail 1st call to timer callback */
if(!rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), rc);
result = testone(URL, 1, 0); /* fail 1st call to timer callback */
if(!result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), result);
rc = testone(URL, 2, 0); /* fail 2nd call to timer callback */
if(!rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), rc);
result = testone(URL, 2, 0); /* fail 2nd call to timer callback */
if(!result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), result);
rc = testone(URL, 0, 1); /* fail 1st call to socket callback */
if(!rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), rc);
result = testone(URL, 0, 1); /* fail 1st call to socket callback */
if(!result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), result);
rc = testone(URL, 0, 2); /* fail 2nd call to socket callback */
if(!rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), rc);
result = testone(URL, 0, 2); /* fail 2nd call to socket callback */
if(!result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t530_tag(), result);
return CURLE_OK;
}

8
tests/libtest/lib586.c
View File

@ -97,7 +97,7 @@ static void t586_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
/* the dummy thread function */
static void *t586_test_fire(void *ptr)
{
CURLcode code;
CURLcode result;
struct t586_Tdata *tdata = (struct t586_Tdata *)ptr;
CURL *curl;
@ -114,11 +114,11 @@ static void *t586_test_fire(void *ptr)
curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
curl_mprintf("PERFORM\n");
code = curl_easy_perform(curl);
if(code != CURLE_OK) {
result = curl_easy_perform(curl);
if(result != CURLE_OK) {
int i = 0;
curl_mfprintf(stderr, "perform URL '%s' repeat %d failed, curlcode %d\n",
tdata->url, i, code);
tdata->url, i, result);
}
curl_mprintf("CLEANUP\n");

8
tests/libtest/lib643.c
View File

@ -224,19 +224,19 @@ static CURLcode t643_cyclic_add(void)
CURL *curl = curl_easy_init();
curl_mime *mime = curl_mime_init(curl);
curl_mimepart *part = curl_mime_addpart(mime);
CURLcode a1 = curl_mime_subparts(part, mime);
CURLcode result = curl_mime_subparts(part, mime);
if(a1 == CURLE_BAD_FUNCTION_ARGUMENT) {
if(result == CURLE_BAD_FUNCTION_ARGUMENT) {
curl_mime *submime = curl_mime_init(curl);
curl_mimepart *subpart = curl_mime_addpart(submime);
curl_mime_subparts(part, submime);
a1 = curl_mime_subparts(subpart, mime);
result = curl_mime_subparts(subpart, mime);
}
curl_mime_free(mime);
curl_easy_cleanup(curl);
if(a1 != CURLE_BAD_FUNCTION_ARGUMENT)
if(result != CURLE_BAD_FUNCTION_ARGUMENT)
/* that should have failed */
return TEST_ERR_FAILURE;

6
tests/libtest/lib678.c
View File

@ -60,7 +60,7 @@ static int loadfile(const char *filename, void **filedata, size_t *filesize)
static CURLcode test_cert_blob(const char *url, const char *cafile)
{
CURLcode code = CURLE_OUT_OF_MEMORY;
CURLcode result = CURLE_OUT_OF_MEMORY;
CURL *curl;
struct curl_blob blob;
size_t certsize;
@ -84,11 +84,11 @@ static CURLcode test_cert_blob(const char *url, const char *cafile)
blob.flags = CURL_BLOB_COPY;
curl_easy_setopt(curl, CURLOPT_CAINFO_BLOB, &blob);
curlx_free(certdata);
code = curl_easy_perform(curl);
result = curl_easy_perform(curl);
}
curl_easy_cleanup(curl);
return code;
return result;
}
static CURLcode test_lib678(const char *URL)

18
tests/libtest/lib758.c
View File

@ -307,15 +307,15 @@ static CURLMcode t758_checkFdSet(CURLM *multi, struct t758_Sockets *sockets,
const char *name)
{
int i;
CURLMcode result = CURLM_OK;
CURLMcode mresult = CURLM_OK;
for(i = 0; i < sockets->count; ++i) {
if(FD_ISSET(sockets->sockets[i], fdset)) {
result = t758_saction(multi, sockets->sockets[i], evBitmask, name);
if(result)
mresult = t758_saction(multi, sockets->sockets[i], evBitmask, name);
if(mresult)
break;
}
}
return result;
return mresult;
}
static CURLcode t758_one(const char *URL, int timer_fail_at,
@ -485,14 +485,14 @@ test_cleanup:
static CURLcode test_lib758(const char *URL)
{
CURLcode rc;
CURLcode result;
/* rerun the same transfer multiple times and make it fail in different
callback calls */
rc = t758_one(URL, 0, 0); /* no callback fails */
if(rc)
curl_mfprintf(stderr, "%s FAILED: %d\n", t758_tag(), rc);
result = t758_one(URL, 0, 0); /* no callback fails */
if(result)
curl_mfprintf(stderr, "%s FAILED: %d\n", t758_tag(), result);
return rc;
return result;
}
#else /* T578_ENABLED */

6
tests/server/getpart.c
View File

@ -185,7 +185,7 @@ static int appenddata(char **dst_buf, /* dest buffer */
static int decodedata(char **buf, /* dest buffer */
size_t *len) /* dest buffer data length */
{
CURLcode error = CURLE_OK;
CURLcode result = CURLE_OK;
unsigned char *buf64 = NULL;
size_t src_len = 0;
@ -193,8 +193,8 @@ static int decodedata(char **buf, /* dest buffer */
return GPE_OK;
/* base64 decode the given buffer */
error = curlx_base64_decode(*buf, &buf64, &src_len);
if(error)
result = curlx_base64_decode(*buf, &buf64, &src_len);
if(result)
return GPE_OUT_OF_MEMORY;
if(!src_len) {

26
tests/unit/unit1302.c
View File

@ -36,7 +36,7 @@ struct etest {
static CURLcode test_unit1302(const char *arg)
{
UNITTEST_BEGIN_SIMPLE
CURLcode rc;
CURLcode result;
unsigned int i;
/* common base64 encoding */
@ -132,8 +132,9 @@ static CURLcode test_unit1302(const char *arg)
size_t dlen;
/* first encode */
rc = curlx_base64_encode((const uint8_t *)e->input, e->ilen, &out, &olen);
abort_unless(rc == CURLE_OK, "return code should be CURLE_OK");
result = curlx_base64_encode((const uint8_t *)e->input, e->ilen,
&out, &olen);
abort_unless(result == CURLE_OK, "return code should be CURLE_OK");
abort_unless(olen == e->olen, "wrong output size");
if(memcmp(out, e->output, e->olen)) {
curl_mfprintf(stderr, "Test %u encoded badly\n", i);
@ -142,9 +143,10 @@ static CURLcode test_unit1302(const char *arg)
Curl_safefree(out);
/* then verify decode */
rc = curlx_base64_decode(e->output, &decoded, &dlen);
if(rc != CURLE_OK) {
curl_mfprintf(stderr, "Test %u URL decode returned %d\n", i, (int)rc);
result = curlx_base64_decode(e->output, &decoded, &dlen);
if(result != CURLE_OK) {
curl_mfprintf(stderr, "Test %u URL decode returned %d\n", i,
(int)result);
unitfail++;
}
if(dlen != e->ilen) {
@ -165,9 +167,9 @@ static CURLcode test_unit1302(const char *arg)
struct etest *e = &url[i];
char *out;
size_t olen;
rc = curlx_base64url_encode((const uint8_t *)e->input, e->ilen,
&out, &olen);
abort_unless(rc == CURLE_OK, "return code should be CURLE_OK");
result = curlx_base64url_encode((const uint8_t *)e->input, e->ilen,
&out, &olen);
abort_unless(result == CURLE_OK, "return code should be CURLE_OK");
if(olen != e->olen) {
curl_mfprintf(stderr, "Test %u URL encoded output length %zu "
"instead of %zu\n", i, olen, e->olen);
@ -186,11 +188,11 @@ static CURLcode test_unit1302(const char *arg)
size_t dlen;
/* then verify decode with illegal inputs */
rc = curlx_base64_decode(e->output, &decoded, &dlen);
if(rc != CURLE_BAD_CONTENT_ENCODING) {
result = curlx_base64_decode(e->output, &decoded, &dlen);
if(result != CURLE_BAD_CONTENT_ENCODING) {
curl_mfprintf(stderr, "Test %u URL bad decoded badly. "
"Returned '%d', expected '%d'\n",
i, (int)rc, CURLE_BAD_CONTENT_ENCODING);
i, (int)result, CURLE_BAD_CONTENT_ENCODING);
unitfail++;
}
}

4
tests/unit/unit1305.c
View File

@ -106,8 +106,8 @@ static CURLcode test_unit1305(const char *arg)
/* Test 1305 exits without adding anything to the hash */
if(testnum == 1306) {
CURLcode rc = create_node();
abort_unless(rc == CURLE_OK, "data node creation failed");
CURLcode result = create_node();
abort_unless(result == CURLE_OK, "data node creation failed");
key_len = strlen(data_key);
data_node->refcount = 1; /* hash will hold the reference */

6
tests/unit/unit1608.c
View File

@ -48,14 +48,14 @@ static CURLcode test_unit1608(const char *arg)
UNITTEST_BEGIN(t1608_setup())
int i;
CURLcode code;
CURLcode result;
struct Curl_addrinfo *addrhead = addrs;
struct Curl_easy *easy = curl_easy_init();
abort_unless(easy, "out of memory");
code = curl_easy_setopt(easy, CURLOPT_DNS_SHUFFLE_ADDRESSES, 1L);
abort_unless(code == CURLE_OK, "curl_easy_setopt failed");
result = curl_easy_setopt(easy, CURLOPT_DNS_SHUFFLE_ADDRESSES, 1L);
abort_unless(result == CURLE_OK, "curl_easy_setopt failed");
/* Shuffle repeatedly and make sure that the list changes */
for(i = 0; i < 10; i++) {

30
tests/unit/unit1620.c
View File

@ -41,9 +41,9 @@ static void t1620_parse(const char *input,
char *userstr = NULL;
char *passwdstr = NULL;
char *options = NULL;
CURLcode rc = Curl_parse_login_details(input, strlen(input), &userstr,
&passwdstr, &options);
fail_unless(rc == CURLE_OK, "Curl_parse_login_details() failed");
CURLcode result = Curl_parse_login_details(input, strlen(input), &userstr,
&passwdstr, &options);
fail_unless(result == CURLE_OK, "Curl_parse_login_details() failed");
fail_unless(!!exp_username == !!userstr, "username expectation failed");
fail_unless(!!exp_password == !!passwdstr, "password expectation failed");
@ -70,32 +70,32 @@ static CURLcode test_unit1620(const char *arg)
{
UNITTEST_BEGIN(t1620_setup())
CURLcode rc;
CURLcode result;
struct Curl_easy *empty;
enum dupstring i;
bool async = FALSE;
bool protocol_connect = FALSE;
rc = Curl_open(&empty);
if(rc)
result = Curl_open(&empty);
if(result)
goto unit_test_abort;
fail_unless(rc == CURLE_OK, "Curl_open() failed");
fail_unless(result == CURLE_OK, "Curl_open() failed");
rc = Curl_connect(empty, &async, &protocol_connect);
fail_unless(rc == CURLE_URL_MALFORMAT,
result = Curl_connect(empty, &async, &protocol_connect);
fail_unless(result == CURLE_URL_MALFORMAT,
"Curl_connect() failed to return CURLE_URL_MALFORMAT");
fail_unless(empty->magic == CURLEASY_MAGIC_NUMBER,
"empty->magic should be equal to CURLEASY_MAGIC_NUMBER");
/* double invoke to ensure no dependency on internal state */
rc = Curl_connect(empty, &async, &protocol_connect);
fail_unless(rc == CURLE_URL_MALFORMAT,
result = Curl_connect(empty, &async, &protocol_connect);
fail_unless(result == CURLE_URL_MALFORMAT,
"Curl_connect() failed to return CURLE_URL_MALFORMAT");
rc = Curl_init_do(empty, empty->conn);
fail_unless(rc == CURLE_OK, "Curl_init_do() failed");
result = Curl_init_do(empty, empty->conn);
fail_unless(result == CURLE_OK, "Curl_init_do() failed");
t1620_parse("hostname", "hostname", NULL, NULL);
t1620_parse("user:password", "user", "password", NULL);
@ -118,8 +118,8 @@ static CURLcode test_unit1620(const char *arg)
fail_unless(empty->set.str[i] == NULL, "Curl_free() did not set to NULL");
}
rc = Curl_close(&empty);
fail_unless(rc == CURLE_OK, "Curl_close() failed");
result = Curl_close(&empty);
fail_unless(result == CURLE_OK, "Curl_close() failed");
UNITTEST_END(curl_global_cleanup())
}

6
tests/unit/unit1651.c
View File

@ -364,7 +364,7 @@ static CURLcode test_unit1651(const char *arg)
0x48, 0x88, 0x61, 0x54, 0x4A, 0x2B, 0xB7, 0x6A, 0x12, 0x08, 0xFB,
};
CURLcode res;
CURLcode result;
const char *beg = (const char *)&cert[0];
const char *end = (const char *)&cert[sizeof(cert)];
struct Curl_easy *data;
@ -378,9 +378,9 @@ static CURLcode test_unit1651(const char *arg)
data = curl_easy_init();
if(data) {
res = Curl_extract_certinfo(data, 0, beg, end);
result = Curl_extract_certinfo(data, 0, beg, end);
fail_unless(res == CURLE_OK, "Curl_extract_certinfo returned error");
fail_unless(result == CURLE_OK, "Curl_extract_certinfo returned error");
/* a poor man's fuzzing of some initial data to make sure nothing bad
happens */

120
tests/unit/unit1654.c
View File

@ -33,12 +33,12 @@ static CURLcode test_unit1654(const char *arg)
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_ALTSVC)
char outname[256];
CURL *curl;
CURLcode res;
CURLcode result;
struct altsvcinfo *asi = Curl_altsvc_init();
abort_if(!asi, "Curl_altsvc_i");
res = Curl_altsvc_load(asi, arg);
if(res) {
fail_if(res, "Curl_altsvc_load");
result = Curl_altsvc_load(asi, arg);
if(result) {
fail_if(result, "Curl_altsvc_load");
goto fail;
}
curl_global_init(CURL_GLOBAL_ALL);
@ -50,92 +50,92 @@ static CURLcode test_unit1654(const char *arg)
fail_unless(Curl_llist_count(&asi->list) == 4, "wrong number of entries");
curl_msnprintf(outname, sizeof(outname), "%s-out", arg);
res = Curl_altsvc_parse(curl, asi, "h2=\"example.com:8080\"\r\n",
ALPN_h1, "example.org", 8080);
fail_if(res, "Curl_altsvc_parse() failed!");
result = Curl_altsvc_parse(curl, asi, "h2=\"example.com:8080\"\r\n",
ALPN_h1, "example.org", 8080);
fail_if(result, "Curl_altsvc_parse() failed!");
fail_unless(Curl_llist_count(&asi->list) == 5, "wrong number of entries");
res = Curl_altsvc_parse(curl, asi, "h3=\":8080\"\r\n",
ALPN_h1, "2.example.org", 8080);
fail_if(res, "Curl_altsvc_parse(2) failed!");
result = Curl_altsvc_parse(curl, asi, "h3=\":8080\"\r\n",
ALPN_h1, "2.example.org", 8080);
fail_if(result, "Curl_altsvc_parse(2) failed!");
fail_unless(Curl_llist_count(&asi->list) == 6, "wrong number of entries");
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!");
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!");
/* that one should make two entries */
fail_unless(Curl_llist_count(&asi->list) == 8, "wrong number of entries");
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!");
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!");
fail_unless(Curl_llist_count(&asi->list) == 9, "wrong number of entries");
/* quoted 'ma' value */
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!");
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!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
res = Curl_altsvc_parse(curl, asi,
"h2=\":443\"; ma=180, h3=\":443\"; "
"persist = \"1\"; ma = 120;\r\n",
ALPN_h1, "curl.se", 80);
fail_if(res, "Curl_altsvc_parse(6) failed!");
result = Curl_altsvc_parse(curl, asi,
"h2=\":443\"; ma=180, h3=\":443\"; "
"persist = \"1\"; ma = 120;\r\n",
ALPN_h1, "curl.se", 80);
fail_if(result, "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 */
res = Curl_altsvc_parse(curl, asi, "clear;\r\n",
ALPN_h1, "curl.se", 80);
fail_if(res, "Curl_altsvc_parse(7) failed!");
result = Curl_altsvc_parse(curl, asi, "clear;\r\n",
ALPN_h1, "curl.se", 80);
fail_if(result, "Curl_altsvc_parse(7) failed!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
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!");
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!");
fail_unless(Curl_llist_count(&asi->list) == 12, "wrong number of entries");
/* clear - without semicolon */
res = Curl_altsvc_parse(curl, asi, "clear\r\n",
ALPN_h1, "curl.se", 80);
fail_if(res, "Curl_altsvc_parse(7) failed!");
result = Curl_altsvc_parse(curl, asi, "clear\r\n",
ALPN_h1, "curl.se", 80);
fail_if(result, "Curl_altsvc_parse(7) failed!");
fail_unless(Curl_llist_count(&asi->list) == 10, "wrong number of entries");
/* only a non-existing alpn */
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!");
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!");
/* missing quote in alpn host */
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!");
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!");
/* missing port in hostname */
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!");
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!");
/* illegal port in hostname */
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!");
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=\"test2.se:443\"; ma=\"180 \" ; unknown=2, "
"h2=\"test3.se:443\"; ma = 120;\r\n",
ALPN_h2, "test.se", 443);
fail_if(res, "Curl_altsvc_parse(12) failed!");
result = Curl_altsvc_parse(curl, asi,
"h2=\"test2.se:443\"; ma=\"180 \" ; unknown=2, "
"h2=\"test3.se:443\"; ma = 120;\r\n",
ALPN_h2, "test.se", 443);
fail_if(result, "Curl_altsvc_parse(12) failed!");
Curl_altsvc_save(curl, asi, outname);

12
tests/unit/unit1656.c
View File

@ -30,23 +30,23 @@
struct test_spec {
const char *input;
const char *exp_output;
CURLcode exp_res;
CURLcode result_exp;
};
static bool do_test(const struct test_spec *spec, size_t i,
struct dynbuf *dbuf)
{
CURLcode res;
CURLcode result;
const char *in = spec->input;
curlx_dyn_reset(dbuf);
res = Curl_x509_GTime2str(dbuf, in, in + strlen(in));
if(res != spec->exp_res) {
result = Curl_x509_GTime2str(dbuf, in, in + strlen(in));
if(result != spec->result_exp) {
curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
i, spec->exp_res, res);
i, spec->result_exp, result);
return FALSE;
}
else if(!res && strcmp(spec->exp_output, curlx_dyn_ptr(dbuf))) {
else if(!result && 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));

30
tests/unit/unit1657.c
View File

@ -30,26 +30,26 @@
struct test1657_spec {
CURLcode (*setbuf)(const struct test1657_spec *spec, struct dynbuf *buf);
size_t n;
CURLcode exp_res;
CURLcode result_exp;
};
static CURLcode make1657_nested(const struct test1657_spec *spec,
struct dynbuf *buf)
{
CURLcode r;
CURLcode result;
size_t i;
unsigned char open_undef[] = { 0x32, 0x80 };
unsigned char close_undef[] = { 0x00, 0x00 };
for(i = 0; i < spec->n; ++i) {
r = curlx_dyn_addn(buf, open_undef, sizeof(open_undef));
if(r)
return r;
result = curlx_dyn_addn(buf, open_undef, sizeof(open_undef));
if(result)
return result;
}
for(i = 0; i < spec->n; ++i) {
r = curlx_dyn_addn(buf, close_undef, sizeof(close_undef));
if(r)
return r;
result = curlx_dyn_addn(buf, close_undef, sizeof(close_undef));
if(result)
return result;
}
return CURLE_OK;
}
@ -64,22 +64,22 @@ static const struct test1657_spec test1657_specs[] = {
static bool do_test1657(const struct test1657_spec *spec, size_t i,
struct dynbuf *buf)
{
CURLcode res;
CURLcode result;
struct Curl_asn1Element elem;
const char *in;
memset(&elem, 0, sizeof(elem));
curlx_dyn_reset(buf);
res = spec->setbuf(spec, buf);
if(res) {
curl_mfprintf(stderr, "test %zu: error setting buf %d\n", i, res);
result = spec->setbuf(spec, buf);
if(result) {
curl_mfprintf(stderr, "test %zu: error setting buf %d\n", i, result);
return FALSE;
}
in = curlx_dyn_ptr(buf);
res = Curl_x509_getASN1Element(&elem, in, in + curlx_dyn_len(buf));
if(res != spec->exp_res) {
result = Curl_x509_getASN1Element(&elem, in, in + curlx_dyn_len(buf));
if(result != spec->result_exp) {
curl_mfprintf(stderr, "test %zu: expect result %d, got %d\n",
i, spec->exp_res, res);
i, spec->result_exp, result);
return FALSE;
}
return TRUE;

18
tests/unit/unit1660.c
View File

@ -45,9 +45,9 @@ static CURLcode test_unit1660(const char *arg)
struct testit {
const char *host;
const char *chost; /* if non-NULL, use to lookup with */
const char *hdr; /* if NULL, just do the lookup */
const CURLcode res; /* parse result */
const char *chost; /* if non-NULL, use to lookup with */
const char *hdr; /* if NULL, just do the lookup */
const CURLcode result; /* parse result */
};
static const struct testit headers[] = {
@ -102,7 +102,7 @@ static CURLcode test_unit1660(const char *arg)
{ NULL, NULL, NULL, CURLE_OK }
};
CURLcode res;
CURLcode result;
struct stsentry *e;
struct hsts *h = Curl_hsts_init();
int i;
@ -124,16 +124,16 @@ static CURLcode test_unit1660(const char *arg)
for(i = 0; headers[i].host; i++) {
if(headers[i].hdr) {
res = Curl_hsts_parse(h, headers[i].host, headers[i].hdr);
result = Curl_hsts_parse(h, headers[i].host, headers[i].hdr);
if(res != headers[i].res) {
if(result != headers[i].result) {
curl_mfprintf(stderr, "Curl_hsts_parse(%s) failed: %d\n",
headers[i].hdr, res);
headers[i].hdr, result);
unitfail++;
continue;
}
else if(res) {
curl_mprintf("Input %u: error %d\n", i, (int)res);
else if(result) {
curl_mprintf("Input %u: error %d\n", i, (int)result);
continue;
}
}

6
tests/unit/unit1663.c
View File

@ -43,13 +43,13 @@ static void t1663_parse(const char *input_data,
const char *exp_dev,
const char *exp_iface,
const char *exp_host,
CURLcode exp_rc)
CURLcode result_exp)
{
char *dev = NULL;
char *iface = NULL;
char *host = NULL;
CURLcode rc = Curl_parse_interface(input_data, &dev, &iface, &host);
fail_unless(rc == exp_rc, "Curl_parse_interface() failed");
CURLcode result = Curl_parse_interface(input_data, &dev, &iface, &host);
fail_unless(result == result_exp, "Curl_parse_interface() failed");
fail_unless(!!exp_dev == !!dev, "dev expectation failed.");
fail_unless(!!exp_iface == !!iface, "iface expectation failed");

6
tests/unit/unit2600.c
View File

@ -83,7 +83,7 @@ struct test_case {
int exp_cf6_creations;
timediff_t min_duration_ms;
timediff_t max_duration_ms;
CURLcode exp_res;
CURLcode result_exp;
const char *pref_family;
};
@ -242,11 +242,11 @@ static void check_result(const struct test_case *tc, struct test_result *tr)
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_res && CURLE_OPERATION_TIMEDOUT != tr->result) {
if(tr->result != tc->result_exp && CURLE_OPERATION_TIMEDOUT != tr->result) {
/* 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_res, tr->result);
tc->id, tc->result_exp, tr->result);
fail(msg);
}
if(tr->cf4.creations != tc->exp_cf4_creations) {

56
tests/unit/unit2601.c
View File

@ -85,7 +85,7 @@ static void check_bufq(size_t pool_spares,
struct bufq q;
struct bufc_pool pool;
size_t max_len = chunk_size * max_chunks;
CURLcode res;
CURLcode result;
ssize_t i;
size_t n2;
size_t nwritten, nread;
@ -105,20 +105,20 @@ static void check_bufq(size_t pool_spares,
fail_unless(q.spare == NULL, "init: spare not NULL");
fail_unless(Curl_bufq_len(&q) == 0, "init: bufq length != 0");
res = Curl_bufq_write(&q, test_data, wsize, &n2);
result = Curl_bufq_write(&q, test_data, wsize, &n2);
fail_unless(n2 <= wsize, "write: wrong size returned");
fail_unless(res == CURLE_OK, "write: wrong result returned");
fail_unless(result == CURLE_OK, "write: wrong result returned");
/* write empty bufq full */
nwritten = 0;
Curl_bufq_reset(&q);
while(!Curl_bufq_is_full(&q)) {
res = Curl_bufq_write(&q, test_data, wsize, &n2);
if(!res) {
result = Curl_bufq_write(&q, test_data, wsize, &n2);
if(!result) {
nwritten += n2;
}
else if(res != CURLE_AGAIN) {
fail_unless(res == CURLE_AGAIN, "write-loop: unexpected result");
else if(result != CURLE_AGAIN) {
fail_unless(result == CURLE_AGAIN, "write-loop: unexpected result");
break;
}
}
@ -132,12 +132,12 @@ static void check_bufq(size_t pool_spares,
/* read full bufq empty */
nread = 0;
while(!Curl_bufq_is_empty(&q)) {
res = Curl_bufq_read(&q, test_data, rsize, &n2);
if(!res) {
result = Curl_bufq_read(&q, test_data, rsize, &n2);
if(!result) {
nread += n2;
}
else if(res != CURLE_AGAIN) {
fail_unless(res == CURLE_AGAIN, "read-loop: unexpected result");
else if(result != CURLE_AGAIN) {
fail_unless(result == CURLE_AGAIN, "read-loop: unexpected result");
break;
}
}
@ -153,14 +153,14 @@ static void check_bufq(size_t pool_spares,
}
for(i = 0; i < 1000; ++i) {
res = Curl_bufq_write(&q, test_data, wsize, &n2);
if(res && res != CURLE_AGAIN) {
fail_unless(res == CURLE_AGAIN, "rw-loop: unexpected write result");
result = Curl_bufq_write(&q, test_data, wsize, &n2);
if(result && result != CURLE_AGAIN) {
fail_unless(result == CURLE_AGAIN, "rw-loop: unexpected write result");
break;
}
res = Curl_bufq_read(&q, test_data, rsize, &n2);
if(res && res != CURLE_AGAIN) {
fail_unless(res == CURLE_AGAIN, "rw-loop: unexpected read result");
result = Curl_bufq_read(&q, test_data, rsize, &n2);
if(result && result != CURLE_AGAIN) {
fail_unless(result == CURLE_AGAIN, "rw-loop: unexpected read result");
break;
}
}
@ -170,9 +170,9 @@ static void check_bufq(size_t pool_spares,
Curl_bufq_init2(&q, chunk_size, max_chunks, (opts | BUFQ_OPT_SOFT_LIMIT));
nwritten = 0;
while(!Curl_bufq_is_full(&q)) {
res = Curl_bufq_write(&q, test_data, wsize, &n2);
if(res || n2 != wsize) {
fail_unless(!res && n2 == wsize, "write should be complete");
result = Curl_bufq_write(&q, test_data, wsize, &n2);
if(result || n2 != wsize) {
fail_unless(!result && n2 == wsize, "write should be complete");
break;
}
nwritten += n2;
@ -184,15 +184,15 @@ static void check_bufq(size_t pool_spares,
fail_if(TRUE, "write: bufq full but nwritten wrong");
}
/* do one more write on a full bufq, should work */
res = Curl_bufq_write(&q, test_data, wsize, &n2);
fail_unless(!res && n2 == wsize, "write should be complete");
result = Curl_bufq_write(&q, test_data, wsize, &n2);
fail_unless(!result && n2 == wsize, "write should be complete");
nwritten += n2;
/* see that we get all out again */
nread = 0;
while(!Curl_bufq_is_empty(&q)) {
res = Curl_bufq_read(&q, test_data, rsize, &n2);
if(res) {
fail_unless(res, "read-loop: unexpected fail");
result = Curl_bufq_read(&q, test_data, rsize, &n2);
if(result) {
fail_unless(result, "read-loop: unexpected fail");
break;
}
nread += n2;
@ -211,12 +211,12 @@ static CURLcode test_unit2601(const char *arg)
struct bufq q;
size_t n;
CURLcode res;
CURLcode result;
unsigned char buf[16 * 1024];
Curl_bufq_init(&q, 8 * 1024, 12);
res = Curl_bufq_read(&q, buf, 128, &n);
fail_unless(res && res == CURLE_AGAIN, "read empty fail");
result = Curl_bufq_read(&q, buf, 128, &n);
fail_unless(result && result == CURLE_AGAIN, "read empty fail");
Curl_bufq_free(&q);
check_bufq(0, 1024, 4, 128, 128, BUFQ_OPT_NONE);

12
tests/unit/unit2602.c
View File

@ -33,7 +33,7 @@ static CURLcode test_unit2602(const char *arg)
struct dynhds hds;
struct dynbuf dbuf;
CURLcode res;
CURLcode result;
size_t i;
/* add 1 more header than allowed */
@ -62,8 +62,8 @@ static CURLcode test_unit2602(const char *arg)
}
fail_unless(Curl_dynhds_count(&hds) == 2, "should hold 2");
/* exceed limit on # of entries */
res = Curl_dynhds_add(&hds, "test3", 5, "789", 3);
fail_unless(res, "add should have failed");
result = Curl_dynhds_add(&hds, "test3", 5, "789", 3);
fail_unless(result, "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");
@ -94,9 +94,9 @@ static CURLcode test_unit2602(const char *arg)
fail_unless(Curl_dynhds_cremove(&hds, "blablabla") == 2, "should");
fail_if(Curl_dynhds_ccontains(&hds, "blablabla"), "should not");
res = Curl_dynhds_h1_cadd_line(&hds, "blablabla thingies");
fail_unless(res, "add should have failed");
if(!res) {
result = Curl_dynhds_h1_cadd_line(&hds, "blablabla thingies");
fail_unless(result, "add should have failed");
if(!result) {
fail_unless(Curl_dynhds_ccount_name(&hds, "bLABlaBlA") == 0, "should");
fail_if(Curl_dynhds_cadd(&hds, "Bla-Bla", "thingies"), "add failed");

10
tests/unit/unit2603.c
View File

@ -65,7 +65,7 @@ static void parse_success(const struct tcase *t)
struct h1_req_parser p;
const uint8_t *buf;
size_t buflen, i, in_len, in_consumed;
CURLcode err;
CURLcode result;
size_t nread;
Curl_h1_req_parse_init(&p, 1024);
@ -74,10 +74,10 @@ static void parse_success(const struct tcase *t)
buf = (const uint8_t *)t->input[i];
buflen = strlen(t->input[i]);
in_len += buflen;
err = Curl_h1_req_parse_read(&p, buf, buflen, t->default_scheme,
t->custom_method, 0, &nread);
if(err) {
curl_mfprintf(stderr, "got err %d parsing: '%s'\n", err, buf);
result = Curl_h1_req_parse_read(&p, buf, buflen, t->default_scheme,
t->custom_method, 0, &nread);
if(result) {
curl_mfprintf(stderr, "got result %d parsing: '%s'\n", result, buf);
fail("error consuming");
}
in_consumed += (size_t)nread;

13
tests/unit/unit2605.c
View File

@ -35,7 +35,7 @@ static CURLcode test_unit2605(const char *arg)
curl_off_t filesize;
curl_off_t start;
curl_off_t size;
CURLcode res;
CURLcode result;
};
int i;
@ -77,15 +77,16 @@ static CURLcode test_unit2605(const char *arg)
for(i = 0; list[i].r; i++) {
curl_off_t start;
curl_off_t size;
CURLcode res;
CURLcode result;
curl_mprintf("%u: '%s' (file size: %" FMT_OFF_T ")\n", i, list[i].r,
list[i].filesize);
res = Curl_ssh_range(curl, list[i].r, list[i].filesize, &start, &size);
if(res != list[i].res) {
curl_mprintf("... returned %d\n", res);
result = Curl_ssh_range(curl, list[i].r, list[i].filesize, &start,
&size);
if(result != list[i].result) {
curl_mprintf("... returned %d\n", result);
unitfail++;
}
if(!res) {
if(!result) {
if(start != list[i].start) {
curl_mprintf("... start (%" FMT_OFF_T ") was not %" FMT_OFF_T " \n",
start, list[i].start);

48
tests/unit/unit3200.c
View File

@ -75,7 +75,7 @@ static CURLcode test_unit3200(const char *arg)
#endif
size_t i;
CURLcode res = CURLE_OK;
CURLcode result = CURLE_OK;
for(i = 0; i < CURL_ARRAYSIZE(filecontents); i++) {
FILE *fp;
struct dynbuf buf;
@ -95,62 +95,62 @@ static CURLcode test_unit3200(const char *arg)
curl_mfprintf(stderr, "Test %zd...", i);
switch(i) {
case 0:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\n", line),
fail_unless(!result && line && !strcmp("LINE1\n", line),
"First line failed (1)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE2 NEWLINE\n", line),
fail_unless(!result && line && !strcmp("LINE2 NEWLINE\n", line),
"Second line failed (1)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (1)");
break;
case 1:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\n", line),
fail_unless(!result && line && !strcmp("LINE1\n", line),
"First line failed (2)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE2 NONEWLINE\n", line),
fail_unless(!result && line && !strcmp("LINE2 NONEWLINE\n", line),
"Second line failed (2)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (2)");
break;
case 2:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\n", line),
fail_unless(!result && line && !strcmp("LINE1\n", line),
"First line failed (3)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not detect max read on EOF (3)");
break;
case 3:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\n", line),
fail_unless(!result && line && !strcmp("LINE1\n", line),
"First line failed (4)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not ignore partial on EOF (4)");
break;
case 4:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\n", line),
fail_unless(!result && line && !strcmp("LINE1\n", line),
"First line failed (5)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
fail_unless(!curlx_dyn_len(&buf),
"Did not bail out on too long line");
break;
case 5:
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
line = curlx_dyn_ptr(&buf);
fail_unless(!res && line && !strcmp("LINE1\x1aTEST\n", line),
fail_unless(!result && line && !strcmp("LINE1\x1aTEST\n", line),
"Missed/Misinterpreted ^Z (6)");
res = Curl_get_line(&buf, fp, &eof);
result = Curl_get_line(&buf, fp, &eof);
abort_unless(eof, "Missed EOF (6)");
break;
default:
@ -161,7 +161,7 @@ static CURLcode test_unit3200(const char *arg)
curlx_fclose(fp);
curl_mfprintf(stderr, "OK\n");
}
return res;
return result;
#endif