{
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;
}
}
(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) "
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;
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) {
curl = curl_easy_init();
if(!curl) {
- r = CURLE_OUT_OF_MEMORY;
+ result = CURLE_OUT_OF_MEMORY;
goto out;
}
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) {
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;
}
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;
(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 {
curl_global_cleanup();
curl_mprintf("%d\n", status);
- return (CURLcode)status;
+ return status ? TEST_ERR_FAILURE : CURLE_OK;
test_cleanup:
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));
}
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));
struct pair {
const char *in;
- CURLcode *exp;
+ CURLcode *result_exp;
};
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;
}
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. */
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;
}
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;
"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;
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)
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;
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;
}
}
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 */
static CURLcode test_lib3027(const char *URL)
{
- CURLcode ret = CURLE_OK;
+ CURLcode result = CURLE_OK;
CURL *curl;
start_test_timing();
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;
}
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;
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;
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;
}
/* 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;
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");
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;
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;
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)
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,
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 */
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;
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) {
static CURLcode test_unit1302(const char *arg)
{
UNITTEST_BEGIN_SIMPLE
- CURLcode rc;
+ CURLcode result;
unsigned int i;
/* common base64 encoding */
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);
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) {
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);
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++;
}
}
/* 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 */
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++) {
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");
{
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);
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())
}
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;
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 */
#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);
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!");
-
- 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=\"example.net:70000\"; ma=\"180\";\r\n",
+ ALPN_h2, "8.example.net", 80);
+ fail_if(result, "Curl_altsvc_parse(11) 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);
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));
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;
}
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;
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[] = {
{ NULL, NULL, NULL, CURLE_OK }
};
- CURLcode res;
+ CURLcode result;
struct stsentry *e;
struct hsts *h = Curl_hsts_init();
int i;
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;
}
}
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");
int exp_cf6_creations;
timediff_t min_duration_ms;
timediff_t max_duration_ms;
- CURLcode exp_res;
+ CURLcode result_exp;
const char *pref_family;
};
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) {
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;
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;
}
}
/* 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;
}
}
}
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;
}
}
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;
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;
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);
struct dynhds hds;
struct dynbuf dbuf;
- CURLcode res;
+ CURLcode result;
size_t i;
/* add 1 more header than allowed */
}
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");
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");
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);
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;
curl_off_t filesize;
curl_off_t start;
curl_off_t size;
- CURLcode res;
+ CURLcode result;
};
int i;
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);
#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;
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:
curlx_fclose(fp);
curl_mfprintf(stderr, "OK\n");
}
- return res;
+ return result;
#endif
projects / thirdparty / curl.git / commitdiff
