tests/libtest: consistent variable naming for easy/multi/share handles

Follow-up to 928363f28c #19299

Closes #19311

tests/libtest/cli_h2_pausing.c

@@ -46,7 +46,7 @@ struct handle
   int resumed;
   int errored;
   int fail_write;
-  CURL *h;
+  CURL *curl;
 };
 
 static size_t cb(char *data, size_t size, size_t nmemb, void *clientp)
@@ -56,7 +56,7 @@ static size_t cb(char *data, size_t size, size_t nmemb, void *clientp)
   curl_off_t totalsize;
 
   (void)data;
-  if(curl_easy_getinfo(handle->h, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
+  if(curl_easy_getinfo(handle->curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
                        &totalsize) == CURLE_OK)
     curl_mfprintf(stderr, "INFO: [%zu] write, "
                   "Content-Length %" CURL_FORMAT_CURL_OFF_T "\n",
@@ -83,7 +83,7 @@ static size_t cb(char *data, size_t size, size_t nmemb, void *clientp)
 static CURLcode test_cli_h2_pausing(const char *URL)
 {
   struct handle handles[2];
-  CURLM *multi_handle = NULL;
+  CURLM *multi = NULL;
   int still_running = 1, msgs_left, numfds;
   size_t i;
   CURLMsg *msg;
@@ -174,35 +174,39 @@ static CURLcode test_cli_h2_pausing(const char *URL)
     handles[i].resumed = 0;
     handles[i].errored = 0;
     handles[i].fail_write = 1;
-    handles[i].h = curl_easy_init();
-    if(!handles[i].h ||
-      curl_easy_setopt(handles[i].h, CURLOPT_WRITEFUNCTION, cb) != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_WRITEDATA, &handles[i])
+    handles[i].curl = curl_easy_init();
+    if(!handles[i].curl ||
+      curl_easy_setopt(handles[i].curl, CURLOPT_WRITEFUNCTION, cb)
         != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_FOLLOWLOCATION, 1L) != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_VERBOSE, 1L) != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_DEBUGFUNCTION, cli_debug_cb)
+      curl_easy_setopt(handles[i].curl, CURLOPT_WRITEDATA, &handles[i])
         != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_SSL_VERIFYPEER, 0L) != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_RESOLVE, resolve) != CURLE_OK ||
-      curl_easy_setopt(handles[i].h, CURLOPT_PIPEWAIT, 1L) ||
-      curl_easy_setopt(handles[i].h, CURLOPT_URL, url) != CURLE_OK) {
+      curl_easy_setopt(handles[i].curl, CURLOPT_FOLLOWLOCATION, 1L)
+        != CURLE_OK ||
+      curl_easy_setopt(handles[i].curl, CURLOPT_VERBOSE, 1L) != CURLE_OK ||
+      curl_easy_setopt(handles[i].curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb)
+        != CURLE_OK ||
+      curl_easy_setopt(handles[i].curl, CURLOPT_SSL_VERIFYPEER, 0L)
+        != CURLE_OK ||
+      curl_easy_setopt(handles[i].curl, CURLOPT_RESOLVE, resolve)
+        != CURLE_OK ||
+      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;
       goto cleanup;
     }
-    curl_easy_setopt(handles[i].h, CURLOPT_HTTP_VERSION, http_version);
+    curl_easy_setopt(handles[i].curl, CURLOPT_HTTP_VERSION, http_version);
   }
 
-  multi_handle = curl_multi_init();
-  if(!multi_handle) {
+  multi = curl_multi_init();
+  if(!multi) {
     curl_mfprintf(stderr, "curl_multi_init() failed - bailing out\n");
     result = (CURLcode)2;
     goto cleanup;
   }
 
   for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
-    if(curl_multi_add_handle(multi_handle, handles[i].h) != CURLM_OK) {
+    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;
       goto cleanup;
@@ -211,7 +215,7 @@ static CURLcode test_cli_h2_pausing(const char *URL)
 
   for(rounds = 0;; rounds++) {
     curl_mfprintf(stderr, "INFO: multi_perform round %d\n", rounds);
-    if(curl_multi_perform(multi_handle, &still_running) != CURLM_OK) {
+    if(curl_multi_perform(multi, &still_running) != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_perform() failed - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
@@ -248,17 +252,17 @@ static CURLcode test_cli_h2_pausing(const char *URL)
       break;
     }
 
-    if(curl_multi_poll(multi_handle, NULL, 0, 100, &numfds) != CURLM_OK) {
+    if(curl_multi_poll(multi, NULL, 0, 100, &numfds) != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_poll() failed - bailing out\n");
       result = (CURLcode)2;
       goto cleanup;
     }
 
     /* !checksrc! disable EQUALSNULL 1 */
-    while((msg = curl_multi_info_read(multi_handle, &msgs_left)) != NULL) {
+    while((msg = curl_multi_info_read(multi, &msgs_left)) != NULL) {
       if(msg->msg == CURLMSG_DONE) {
         for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
-          if(msg->easy_handle == handles[i].h) {
+          if(msg->easy_handle == handles[i].curl) {
             if(handles[i].paused != 1 || !handles[i].resumed) {
               curl_mfprintf(stderr, "ERROR: [%zu] done, paused=%d, "
                             "resumed=%d, result %d - wtf?\n", i,
@@ -291,7 +295,7 @@ static CURLcode test_cli_h2_pausing(const char *URL)
       for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
         curl_mfprintf(stderr, "INFO: [%zu] resumed\n", i);
         handles[i].resumed = 1;
-        curl_easy_pause(handles[i].h, CURLPAUSE_CONT);
+        curl_easy_pause(handles[i].curl, CURLPAUSE_CONT);
       }
     }
   }
@@ -299,15 +303,15 @@ static CURLcode test_cli_h2_pausing(const char *URL)
 cleanup:
 
   for(i = 0; i < CURL_ARRAYSIZE(handles); i++) {
-    curl_multi_remove_handle(multi_handle, handles[i].h);
-    curl_easy_cleanup(handles[i].h);
+    curl_multi_remove_handle(multi, handles[i].curl);
+    curl_easy_cleanup(handles[i].curl);
   }
 
   curl_slist_free_all(resolve);
   curl_free(host);
   curl_free(port);
   curl_url_cleanup(cu);
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return result;

tests/libtest/cli_h2_serverpush.c

@@ -28,26 +28,26 @@
 
 static FILE *out_download = NULL;
 
-static int setup_h2_serverpush(CURL *hnd, const char *url)
+static int setup_h2_serverpush(CURL *curl, const char *url)
 {
   out_download = curlx_fopen("download_0.data", "wb");
   if(!out_download)
     return 1;  /* failed */
 
-  curl_easy_setopt(hnd, CURLOPT_URL, url);
-  curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
 
-  curl_easy_setopt(hnd, CURLOPT_WRITEDATA, out_download);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_download);
 
   /* please be verbose */
-  curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-  curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  curl_easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config);
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
 
   /* wait for pipe connection to confirm */
-  curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
+  curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
 
   return 0; /* all is good */
 }
@@ -56,7 +56,7 @@ static FILE *out_push = NULL;
 
 /* called when there is an incoming push */
 static int server_push_callback(CURL *parent,
-                                CURL *easy,
+                                CURL *curl,
                                 size_t num_headers,
                                 struct curl_pushheaders *headers,
                                 void *userp)
@@ -80,7 +80,7 @@ static int server_push_callback(CURL *parent,
   }
 
   /* write to this file */
-  curl_easy_setopt(easy, CURLOPT_WRITEDATA, out_push);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, out_push);
 
   curl_mfprintf(stderr, "**** push callback approves stream %u, "
                 "got %zu headers!\n", count, num_headers);
@@ -106,8 +106,8 @@ static int server_push_callback(CURL *parent,
  */
 static CURLcode test_cli_h2_serverpush(const char *URL)
 {
-  CURL *easy = NULL;
-  CURLM *multi_handle;
+  CURL *curl = NULL;
+  CURLM *multi;
   int transfers = 1; /* we start with one */
   CURLcode result = CURLE_OK;
 
@@ -124,38 +124,38 @@ static CURLcode test_cli_h2_serverpush(const char *URL)
     return (CURLcode)3;
   }
 
-  multi_handle = curl_multi_init();
-  if(!multi_handle) {
+  multi = curl_multi_init();
+  if(!multi) {
     result = (CURLcode)1;
     goto cleanup;
   }
 
-  easy = curl_easy_init();
-  if(!easy) {
+  curl = curl_easy_init();
+  if(!curl) {
     result = (CURLcode)1;
     goto cleanup;
   }
 
-  if(setup_h2_serverpush(easy, URL)) {
+  if(setup_h2_serverpush(curl, URL)) {
     curl_mfprintf(stderr, "failed\n");
     result = (CURLcode)1;
     goto cleanup;
   }
 
-  curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
-  curl_multi_setopt(multi_handle, CURLMOPT_PUSHFUNCTION, server_push_callback);
-  curl_multi_setopt(multi_handle, CURLMOPT_PUSHDATA, &transfers);
+  curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+  curl_multi_setopt(multi, CURLMOPT_PUSHFUNCTION, server_push_callback);
+  curl_multi_setopt(multi, CURLMOPT_PUSHDATA, &transfers);
 
-  curl_multi_add_handle(multi_handle, easy);
+  curl_multi_add_handle(multi, curl);
 
   do {
     struct CURLMsg *m;
     int still_running; /* keep number of running handles */
-    CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+    CURLMcode mc = curl_multi_perform(multi, &still_running);
 
     if(still_running)
       /* wait for activity, timeout or "nothing" */
-      mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+      mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
 
     if(mc)
       break;
@@ -167,12 +167,12 @@ static CURLcode test_cli_h2_serverpush(const char *URL)
      */
     do {
       int msgq = 0;
-      m = curl_multi_info_read(multi_handle, &msgq);
+      m = curl_multi_info_read(multi, &msgq);
       if(m && (m->msg == CURLMSG_DONE)) {
-        CURL *e = m->easy_handle;
+        CURL *easy = m->easy_handle;
         transfers--;
-        curl_multi_remove_handle(multi_handle, e);
-        curl_easy_cleanup(e);
+        curl_multi_remove_handle(multi, easy);
+        curl_easy_cleanup(easy);
       }
     } while(m);
 
@@ -180,7 +180,7 @@ static CURLcode test_cli_h2_serverpush(const char *URL)
 
 cleanup:
 
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup(multi);
 
   if(out_download)
     curlx_fclose(out_download);

tests/libtest/cli_h2_upgrade_extreme.c

@@ -37,7 +37,7 @@ static size_t write_h2_upg_extreme_cb(char *ptr, size_t size, size_t nmemb,
 static CURLcode test_cli_h2_upgrade_extreme(const char *URL)
 {
   CURLM *multi = NULL;
-  CURL *easy;
+  CURL *curl;
   CURLMcode mc;
   int running_handles = 0, start_count, numfds;
   CURLMsg *msg;
@@ -64,33 +64,33 @@ static CURLcode test_cli_h2_upgrade_extreme(const char *URL)
   start_count = 200;
   do {
     if(start_count) {
-      easy = curl_easy_init();
-      if(!easy) {
+      curl = curl_easy_init();
+      if(!curl) {
         curl_mfprintf(stderr, "curl_easy_init failed\n");
         goto cleanup;
       }
-      curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L);
-      curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
-      curl_easy_setopt(easy, CURLOPT_URL, URL);
-      curl_easy_setopt(easy, CURLOPT_NOSIGNAL, 1L);
-      curl_easy_setopt(easy, CURLOPT_AUTOREFERER, 1L);
-      curl_easy_setopt(easy, CURLOPT_FAILONERROR, 1L);
-      curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
-      curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, write_h2_upg_extreme_cb);
-      curl_easy_setopt(easy, CURLOPT_WRITEDATA, NULL);
-      curl_easy_setopt(easy, CURLOPT_HTTPGET, 1L);
+      curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+      curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
+      curl_easy_setopt(curl, CURLOPT_URL, URL);
+      curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
+      curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L);
+      curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
+      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_h2_upg_extreme_cb);
+      curl_easy_setopt(curl, CURLOPT_WRITEDATA, NULL);
+      curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
       curl_msnprintf(range, sizeof(range),
                      "%" CURL_FORMAT_CURL_OFF_TU "-"
                      "%" CURL_FORMAT_CURL_OFF_TU,
                      (curl_off_t)0,
                      (curl_off_t)16384);
-      curl_easy_setopt(easy, CURLOPT_RANGE, range);
+      curl_easy_setopt(curl, CURLOPT_RANGE, range);
 
-      mc = curl_multi_add_handle(multi, easy);
+      mc = curl_multi_add_handle(multi, curl);
       if(mc != CURLM_OK) {
         curl_mfprintf(stderr, "curl_multi_add_handle: %s\n",
                       curl_multi_strerror(mc));
-        curl_easy_cleanup(easy);
+        curl_easy_cleanup(curl);
         goto cleanup;
       }
       --start_count;

tests/libtest/cli_hx_download.c

@@ -51,7 +51,7 @@ static int verbose_d = 1;
 
 struct transfer_d {
   size_t idx;
-  CURL *easy;
+  CURL *curl;
   char filename[128];
   FILE *out;
   curl_off_t recv_size;
@@ -70,11 +70,11 @@ static size_t transfer_count_d = 1;
 static struct transfer_d *transfer_d;
 static int forbid_reuse_d = 0;
 
-static struct transfer_d *get_transfer_for_easy_d(CURL *easy)
+static struct transfer_d *get_transfer_for_easy_d(CURL *curl)
 {
   size_t i;
   for(i = 0; i < transfer_count_d; ++i) {
-    if(easy == transfer_d[i].easy)
+    if(curl == transfer_d[i].curl)
       return &transfer_d[i];
   }
   return NULL;
@@ -143,7 +143,7 @@ static int my_progress_d_cb(void *userdata,
     CURLcode res;
 
     t->checked_ssl = TRUE;
-    res = curl_easy_getinfo(t->easy, CURLINFO_TLS_SSL_PTR, &tls);
+    res = curl_easy_getinfo(t->curl, CURLINFO_TLS_SSL_PTR, &tls);
     if(res) {
       curl_mfprintf(stderr, "[t-%zu] info CURLINFO_TLS_SSL_PTR failed: %d\n",
                     t->idx, res);
@@ -212,40 +212,40 @@ static int my_progress_d_cb(void *userdata,
   return 0;
 }
 
-static int setup_hx_download(CURL *hnd, const char *url, struct transfer_d *t,
+static int setup_hx_download(CURL *curl, const char *url, struct transfer_d *t,
                              long http_version, struct curl_slist *host,
                              CURLSH *share, int use_earlydata,
                              int fresh_connect)
 {
-  curl_easy_setopt(hnd, CURLOPT_SHARE, share);
-  curl_easy_setopt(hnd, CURLOPT_URL, url);
-  curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, http_version);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
-  curl_easy_setopt(hnd, CURLOPT_ACCEPT_ENCODING, "");
-  curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, (long)(128 * 1024));
-  curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, my_write_d_cb);
-  curl_easy_setopt(hnd, CURLOPT_WRITEDATA, t);
-  curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L);
-  curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, my_progress_d_cb);
-  curl_easy_setopt(hnd, CURLOPT_XFERINFODATA, t);
+  curl_easy_setopt(curl, CURLOPT_SHARE, share);
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+  curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
+  curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, (long)(128 * 1024));
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_d_cb);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, t);
+  curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+  curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, my_progress_d_cb);
+  curl_easy_setopt(curl, CURLOPT_XFERINFODATA, t);
   if(use_earlydata)
-    curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA);
+    curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA);
   if(forbid_reuse_d)
-    curl_easy_setopt(hnd, CURLOPT_FORBID_REUSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1L);
   if(host)
-    curl_easy_setopt(hnd, CURLOPT_RESOLVE, host);
+    curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
   if(fresh_connect)
-    curl_easy_setopt(hnd, CURLOPT_FRESH_CONNECT, 1L);
+    curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1L);
 
   /* please be verbose */
   if(verbose_d) {
-    curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-    curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
   }
 
   /* wait for pipe connection to confirm */
-  curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
+  curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
 
   return 0; /* all is good */
 }
@@ -278,7 +278,7 @@ static void usage_hx_download(const char *msg)
  */
 static CURLcode test_cli_hx_download(const char *URL)
 {
-  CURLM *multi_handle = NULL;
+  CURLM *multi = NULL;
   struct CURLMsg *m;
   CURLSH *share = NULL;
   const char *url;
@@ -405,11 +405,11 @@ static CURLcode test_cli_hx_download(const char *URL)
     goto cleanup;
   }
 
-  multi_handle = curl_multi_init();
-  curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
-  curl_multi_setopt(multi_handle, CURLMOPT_MAX_TOTAL_CONNECTIONS,
+  multi = curl_multi_init();
+  curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+  curl_multi_setopt(multi, CURLMOPT_MAX_TOTAL_CONNECTIONS,
                     (long)max_total_conns);
-  curl_multi_setopt(multi_handle, CURLMOPT_MAX_HOST_CONNECTIONS,
+  curl_multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS,
                     (long)max_host_conns);
 
   active_transfers = 0;
@@ -424,15 +424,15 @@ static CURLcode test_cli_hx_download(const char *URL)
   n = (max_parallel < transfer_count_d) ? max_parallel : transfer_count_d;
   for(i = 0; i < n; ++i) {
     t = &transfer_d[i];
-    t->easy = curl_easy_init();
-    if(!t->easy ||
-       setup_hx_download(t->easy, url, t, http_version, host, share,
+    t->curl = curl_easy_init();
+    if(!t->curl ||
+       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;
       goto cleanup;
     }
-    curl_multi_add_handle(multi_handle, t->easy);
+    curl_multi_add_handle(multi, t->curl);
     t->started = 1;
     ++active_transfers;
     curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
@@ -440,11 +440,11 @@ static CURLcode test_cli_hx_download(const char *URL)
 
   do {
     int still_running; /* keep number of running handles */
-    CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+    CURLMcode mc = curl_multi_perform(multi, &still_running);
 
     if(still_running) {
       /* wait for activity, timeout or "nothing" */
-      mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+      mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
     }
 
     if(mc)
@@ -452,12 +452,12 @@ static CURLcode test_cli_hx_download(const char *URL)
 
     do {
       int msgq = 0;
-      m = curl_multi_info_read(multi_handle, &msgq);
+      m = curl_multi_info_read(multi, &msgq);
       if(m && (m->msg == CURLMSG_DONE)) {
-        CURL *e = m->easy_handle;
+        CURL *easy = m->easy_handle;
         --active_transfers;
-        curl_multi_remove_handle(multi_handle, e);
-        t = get_transfer_for_easy_d(e);
+        curl_multi_remove_handle(multi, easy);
+        t = get_transfer_for_easy_d(easy);
         if(t) {
           t->done = 1;
           t->result = m->data.result;
@@ -465,13 +465,13 @@ static CURLcode test_cli_hx_download(const char *URL)
                         t->idx, t->result);
           if(use_earlydata) {
             curl_off_t sent;
-            curl_easy_getinfo(e, CURLINFO_EARLYDATA_SENT_T, &sent);
+            curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent);
             curl_mfprintf(stderr, "[t-%zu] EarlyData: "
                           "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent);
           }
         }
         else {
-          curl_easy_cleanup(e);
+          curl_easy_cleanup(easy);
           curl_mfprintf(stderr, "unknown FINISHED???\n");
         }
       }
@@ -481,8 +481,8 @@ static CURLcode test_cli_hx_download(const char *URL)
         /* abort paused transfers */
         for(i = 0; i < transfer_count_d; ++i) {
           t = &transfer_d[i];
-          if(!t->done && t->paused && t->easy) {
-            curl_multi_remove_handle(multi_handle, t->easy);
+          if(!t->done && t->paused && t->curl) {
+            curl_multi_remove_handle(multi, t->curl);
             t->done = 1;
             active_transfers--;
             curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx);
@@ -496,7 +496,7 @@ static CURLcode test_cli_hx_download(const char *URL)
           if(!t->done && t->paused) {
             t->resumed = 1;
             t->paused = 0;
-            curl_easy_pause(t->easy, CURLPAUSE_CONT);
+            curl_easy_pause(t->curl, CURLPAUSE_CONT);
             curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx);
             break;
           }
@@ -507,15 +507,15 @@ static CURLcode test_cli_hx_download(const char *URL)
         for(i = 0; i < transfer_count_d; ++i) {
           t = &transfer_d[i];
           if(!t->started) {
-            t->easy = curl_easy_init();
-            if(!t->easy ||
-              setup_hx_download(t->easy, url, t, http_version, host, share,
+            t->curl = curl_easy_init();
+            if(!t->curl ||
+              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;
               goto cleanup;
             }
-            curl_multi_add_handle(multi_handle, t->easy);
+            curl_multi_add_handle(multi, t->curl);
             t->started = 1;
             ++active_transfers;
             curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
@@ -532,7 +532,7 @@ static CURLcode test_cli_hx_download(const char *URL)
 
 cleanup:
 
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup(multi);
 
   if(transfer_d) {
     for(i = 0; i < transfer_count_d; ++i) {
@@ -541,9 +541,9 @@ cleanup:
         curlx_fclose(t->out);
         t->out = NULL;
       }
-      if(t->easy) {
-        curl_easy_cleanup(t->easy);
-        t->easy = NULL;
+      if(t->curl) {
+        curl_easy_cleanup(t->curl);
+        t->curl = NULL;
       }
       if(t->result)
         result = t->result;

tests/libtest/cli_hx_upload.c

@@ -30,7 +30,7 @@ static int verbose_u = 1;
 
 struct transfer_u {
   size_t idx;
-  CURL *easy;
+  CURL *curl;
   const char *method;
   char filename[128];
   curl_mime *mime;
@@ -51,11 +51,11 @@ static size_t transfer_count_u = 1;
 static struct transfer_u *transfer_u;
 static int forbid_reuse_u = 0;
 
-static struct transfer_u *get_transfer_for_easy_u(CURL *easy)
+static struct transfer_u *get_transfer_for_easy_u(CURL *curl)
 {
   size_t i;
   for(i = 0; i < transfer_count_u; ++i) {
-    if(easy == transfer_u[i].easy)
+    if(curl == transfer_u[i].curl)
       return &transfer_u[i];
   }
   return NULL;
@@ -142,62 +142,62 @@ static int my_progress_u_cb(void *userdata,
   return 0;
 }
 
-static int setup_hx_upload(CURL *hnd, const char *url, struct transfer_u *t,
+static int setup_hx_upload(CURL *curl, const char *url, struct transfer_u *t,
                            long http_version, struct curl_slist *host,
                            CURLSH *share, int use_earlydata,
                            int announce_length)
 {
-  curl_easy_setopt(hnd, CURLOPT_SHARE, share);
-  curl_easy_setopt(hnd, CURLOPT_URL, url);
-  curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, http_version);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYPEER, 0L);
-  curl_easy_setopt(hnd, CURLOPT_SSL_VERIFYHOST, 0L);
-  curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, (long)(128 * 1024));
-  curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, CURLFOLLOW_OBEYCODE);
-  curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, my_write_u_cb);
-  curl_easy_setopt(hnd, CURLOPT_WRITEDATA, t);
+  curl_easy_setopt(curl, CURLOPT_SHARE, share);
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+  curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, (long)(128 * 1024));
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, CURLFOLLOW_OBEYCODE);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, my_write_u_cb);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, t);
   if(use_earlydata)
-    curl_easy_setopt(hnd, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA);
+    curl_easy_setopt(curl, CURLOPT_SSL_OPTIONS, CURLSSLOPT_EARLYDATA);
 
   if(!strcmp("MIME", t->method)) {
     curl_mimepart *part;
-    t->mime = curl_mime_init(hnd);
+    t->mime = curl_mime_init(curl);
     part = curl_mime_addpart(t->mime);
     curl_mime_name(part, "file");
     curl_mime_data_cb(part, -1, my_read_cb, NULL, NULL, t);
-    curl_easy_setopt(hnd, CURLOPT_MIMEPOST, t->mime);
+    curl_easy_setopt(curl, CURLOPT_MIMEPOST, t->mime);
   }
   else {
     if(!t->method || !strcmp("PUT", t->method))
-      curl_easy_setopt(hnd, CURLOPT_UPLOAD, 1L);
+      curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
     else if(!strcmp("POST", t->method))
-      curl_easy_setopt(hnd, CURLOPT_POST, 1L);
+      curl_easy_setopt(curl, CURLOPT_POST, 1L);
     else {
       curl_mfprintf(stderr, "unsupported method '%s'\n", t->method);
       return 1;
     }
-    curl_easy_setopt(hnd, CURLOPT_READFUNCTION, my_read_cb);
-    curl_easy_setopt(hnd, CURLOPT_READDATA, t);
+    curl_easy_setopt(curl, CURLOPT_READFUNCTION, my_read_cb);
+    curl_easy_setopt(curl, CURLOPT_READDATA, t);
     if(announce_length)
-      curl_easy_setopt(hnd, CURLOPT_INFILESIZE_LARGE, t->send_total);
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, t->send_total);
   }
 
-  curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L);
-  curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, my_progress_u_cb);
-  curl_easy_setopt(hnd, CURLOPT_XFERINFODATA, t);
+  curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+  curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, my_progress_u_cb);
+  curl_easy_setopt(curl, CURLOPT_XFERINFODATA, t);
   if(forbid_reuse_u)
-    curl_easy_setopt(hnd, CURLOPT_FORBID_REUSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1L);
   if(host)
-    curl_easy_setopt(hnd, CURLOPT_RESOLVE, host);
+    curl_easy_setopt(curl, CURLOPT_RESOLVE, host);
 
   /* please be verbose */
   if(verbose_u) {
-    curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-    curl_easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+    curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
   }
 
   /* wait for pipe connection to confirm */
-  curl_easy_setopt(hnd, CURLOPT_PIPEWAIT, 1L);
+  curl_easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
 
   return 0; /* all is good */
 }
@@ -227,7 +227,7 @@ static void usage_hx_upload(const char *msg)
  */
 static CURLcode test_cli_hx_upload(const char *URL)
 {
-  CURLM *multi_handle;
+  CURLM *multi;
   CURLSH *share;
   const char *url;
   const char *method = "PUT";
@@ -369,8 +369,8 @@ static CURLcode test_cli_hx_upload(const char *URL)
   }
 
   if(reuse_easy) {
-    CURL *easy = curl_easy_init();
-    if(!easy) {
+    CURL *curl = curl_easy_init();
+    if(!curl) {
       curl_mfprintf(stderr, "failed to init easy handle\n");
       result = (CURLcode)1;
       goto cleanup;
@@ -378,8 +378,8 @@ static CURLcode test_cli_hx_upload(const char *URL)
     for(i = 0; i < transfer_count_u; ++i) {
       CURLcode rc;
       t = &transfer_u[i];
-      t->easy = easy;
-      if(setup_hx_upload(t->easy, url, t, http_version, host, share,
+      t->curl = curl;
+      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;
@@ -387,28 +387,28 @@ static CURLcode test_cli_hx_upload(const char *URL)
       }
 
       curl_mfprintf(stderr, "[t-%zu] STARTING\n", t->idx);
-      rc = curl_easy_perform(easy);
+      rc = curl_easy_perform(curl);
       curl_mfprintf(stderr, "[t-%zu] DONE -> %d\n", t->idx, rc);
-      t->easy = NULL;
-      curl_easy_reset(easy);
+      t->curl = NULL;
+      curl_easy_reset(curl);
     }
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
   }
   else {
-    multi_handle = curl_multi_init();
-    curl_multi_setopt(multi_handle, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+    multi = curl_multi_init();
+    curl_multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
 
     n = (max_parallel < transfer_count_u) ? max_parallel : transfer_count_u;
     for(i = 0; i < n; ++i) {
       t = &transfer_u[i];
-      t->easy = curl_easy_init();
-      if(!t->easy || setup_hx_upload(t->easy, url, t, http_version, host,
+      t->curl = curl_easy_init();
+      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;
         goto cleanup;
       }
-      curl_multi_add_handle(multi_handle, t->easy);
+      curl_multi_add_handle(multi, t->curl);
       t->started = 1;
       ++active_transfers;
       curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
@@ -416,12 +416,12 @@ static CURLcode test_cli_hx_upload(const char *URL)
 
     do {
       int still_running; /* keep number of running handles */
-      CURLMcode mc = curl_multi_perform(multi_handle, &still_running);
+      CURLMcode mc = curl_multi_perform(multi, &still_running);
       struct CURLMsg *m;
 
       if(still_running) {
         /* wait for activity, timeout or "nothing" */
-        mc = curl_multi_poll(multi_handle, NULL, 0, 1000, NULL);
+        mc = curl_multi_poll(multi, NULL, 0, 1000, NULL);
       }
 
       if(mc)
@@ -429,28 +429,28 @@ static CURLcode test_cli_hx_upload(const char *URL)
 
       do {
         int msgq = 0;
-        m = curl_multi_info_read(multi_handle, &msgq);
+        m = curl_multi_info_read(multi, &msgq);
         if(m && (m->msg == CURLMSG_DONE)) {
-          CURL *e = m->easy_handle;
+          CURL *easy = m->easy_handle;
           --active_transfers;
-          curl_multi_remove_handle(multi_handle, e);
-          t = get_transfer_for_easy_u(e);
+          curl_multi_remove_handle(multi, easy);
+          t = get_transfer_for_easy_u(easy);
           if(t) {
             long res_status;
-            curl_easy_getinfo(e, CURLINFO_RESPONSE_CODE, &res_status);
+            curl_easy_getinfo(easy, CURLINFO_RESPONSE_CODE, &res_status);
             t->done = 1;
             curl_mfprintf(stderr, "[t-%zu] FINISHED, "
                           "result=%d, response=%ld\n",
                           t->idx, m->data.result, res_status);
             if(use_earlydata) {
               curl_off_t sent;
-              curl_easy_getinfo(e, CURLINFO_EARLYDATA_SENT_T, &sent);
+              curl_easy_getinfo(easy, CURLINFO_EARLYDATA_SENT_T, &sent);
               curl_mfprintf(stderr, "[t-%zu] EarlyData: "
                             "%" CURL_FORMAT_CURL_OFF_T "\n", t->idx, sent);
             }
           }
           else {
-            curl_easy_cleanup(e);
+            curl_easy_cleanup(easy);
             curl_mfprintf(stderr, "unknown FINISHED???\n");
           }
         }
@@ -461,8 +461,8 @@ static CURLcode test_cli_hx_upload(const char *URL)
           /* abort paused transfers */
           for(i = 0; i < transfer_count_u; ++i) {
             t = &transfer_u[i];
-            if(!t->done && t->paused && t->easy) {
-              curl_multi_remove_handle(multi_handle, t->easy);
+            if(!t->done && t->paused && t->curl) {
+              curl_multi_remove_handle(multi, t->curl);
               t->done = 1;
               active_transfers--;
               curl_mfprintf(stderr, "[t-%zu] ABORTED\n", t->idx);
@@ -476,7 +476,7 @@ static CURLcode test_cli_hx_upload(const char *URL)
             if(!t->done && t->paused) {
               t->resumed = 1;
               t->paused = 0;
-              curl_easy_pause(t->easy, CURLPAUSE_CONT);
+              curl_easy_pause(t->curl, CURLPAUSE_CONT);
               curl_mfprintf(stderr, "[t-%zu] RESUMED\n", t->idx);
               break;
             }
@@ -487,15 +487,15 @@ static CURLcode test_cli_hx_upload(const char *URL)
           for(i = 0; i < transfer_count_u; ++i) {
             t = &transfer_u[i];
             if(!t->started) {
-              t->easy = curl_easy_init();
-              if(!t->easy || setup_hx_upload(t->easy, url, t, http_version,
+              t->curl = curl_easy_init();
+              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;
                 goto cleanup;
               }
-              curl_multi_add_handle(multi_handle, t->easy);
+              curl_multi_add_handle(multi, t->curl);
               t->started = 1;
               ++active_transfers;
               curl_mfprintf(stderr, "[t-%zu] STARTED\n", t->idx);
@@ -511,7 +511,7 @@ static CURLcode test_cli_hx_upload(const char *URL)
     } while(active_transfers); /* as long as we have transfers going */
 
     curl_mfprintf(stderr, "all transfers done, cleanup multi\n");
-    curl_multi_cleanup(multi_handle);
+    curl_multi_cleanup(multi);
   }
 
 cleanup:
@@ -523,9 +523,9 @@ cleanup:
         curlx_fclose(t->out);
         t->out = NULL;
       }
-      if(t->easy) {
-        curl_easy_cleanup(t->easy);
-        t->easy = NULL;
+      if(t->curl) {
+        curl_easy_cleanup(t->curl);
+        t->curl = NULL;
       }
       if(t->mime) {
         curl_mime_free(t->mime);

tests/libtest/cli_tls_session_reuse.c

@@ -30,13 +30,13 @@ static int tse_found_tls_session = FALSE;
 
 static size_t write_tse_cb(char *ptr, size_t size, size_t nmemb, void *opaque)
 {
-  CURL *easy = opaque;
+  CURL *curl = opaque;
   (void)ptr;
   if(!tse_found_tls_session) {
     struct curl_tlssessioninfo *tlssession;
     CURLcode rc;
 
-    rc = curl_easy_getinfo(easy, CURLINFO_TLS_SSL_PTR, &tlssession);
+    rc = curl_easy_getinfo(curl, CURLINFO_TLS_SSL_PTR, &tlssession);
     if(rc) {
       curl_mfprintf(stderr, "curl_easy_getinfo(CURLINFO_TLS_SSL_PTR) "
                     "failed: %s\n", curl_easy_strerror(rc));
@@ -61,38 +61,38 @@ static CURL *tse_add_transfer(CURLM *multi, CURLSH *share,
                               struct curl_slist *resolve,
                               const char *url, long http_version)
 {
-  CURL *easy;
+  CURL *curl;
   CURLMcode mc;
 
-  easy = curl_easy_init();
-  if(!easy) {
+  curl = curl_easy_init();
+  if(!curl) {
     curl_mfprintf(stderr, "curl_easy_init failed\n");
     return NULL;
   }
-  curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L);
-  curl_easy_setopt(easy, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
-  curl_easy_setopt(easy, CURLOPT_URL, url);
-  curl_easy_setopt(easy, CURLOPT_SHARE, share);
-  curl_easy_setopt(easy, CURLOPT_NOSIGNAL, 1L);
-  curl_easy_setopt(easy, CURLOPT_AUTOREFERER, 1L);
-  curl_easy_setopt(easy, CURLOPT_FAILONERROR, 1L);
-  curl_easy_setopt(easy, CURLOPT_HTTP_VERSION, http_version);
-  curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, write_tse_cb);
-  curl_easy_setopt(easy, CURLOPT_WRITEDATA, easy);
-  curl_easy_setopt(easy, CURLOPT_HTTPGET, 1L);
-  curl_easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0L);
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, cli_debug_cb);
+  curl_easy_setopt(curl, CURLOPT_URL, url);
+  curl_easy_setopt(curl, CURLOPT_SHARE, share);
+  curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
+  curl_easy_setopt(curl, CURLOPT_AUTOREFERER, 1L);
+  curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
+  curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, http_version);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_tse_cb);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, curl);
+  curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
+  curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
   if(resolve)
-    curl_easy_setopt(easy, CURLOPT_RESOLVE, resolve);
+    curl_easy_setopt(curl, CURLOPT_RESOLVE, resolve);
 
 
-  mc = curl_multi_add_handle(multi, easy);
+  mc = curl_multi_add_handle(multi, curl);
   if(mc != CURLM_OK) {
     curl_mfprintf(stderr, "curl_multi_add_handle: %s\n",
                   curl_multi_strerror(mc));
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
     return NULL;
   }
-  return easy;
+  return curl;
 }
 
 static CURLcode test_cli_tls_session_reuse(const char *URL)

tests/libtest/cli_ws_data.c

@@ -190,7 +190,7 @@ out:
 }
 
 struct test_ws_m1_ctx {
-  CURL *easy;
+  CURL *curl;
   char *send_buf;
   char *recv_buf;
   size_t send_len, nsent;
@@ -216,7 +216,7 @@ static size_t test_ws_data_m1_read(char *buf, size_t nitems, size_t buflen,
     goto out;
 
   if(!ctx->frame_reading) {
-    curl_ws_start_frame(ctx->easy, CURLWS_BINARY, ctx->send_len);
+    curl_ws_start_frame(ctx->curl, CURLWS_BINARY, ctx->send_len);
     ctx->frame_reading = TRUE;
   }
 
@@ -310,8 +310,8 @@ static CURLcode test_ws_data_m1_echo(const char *url,
     goto out;
   }
 
-  m1_ctx.easy = curl_easy_init();
-  if(!m1_ctx.easy) {
+  m1_ctx.curl = curl_easy_init();
+  if(!m1_ctx.curl) {
     r = CURLE_OUT_OF_MEMORY;
     goto out;
   }
@@ -330,22 +330,22 @@ static CURLcode test_ws_data_m1_echo(const char *url,
     m1_ctx.frames_read = 0;
     m1_ctx.frames_written = 0;
     memset(m1_ctx.recv_buf, 0, plen_max);
-    curl_easy_pause(m1_ctx.easy, CURLPAUSE_CONT);
+    curl_easy_pause(m1_ctx.curl, CURLPAUSE_CONT);
 
-    curl_easy_reset(m1_ctx.easy);
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_URL, url);
+    curl_easy_reset(m1_ctx.curl);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_URL, url);
     /* use the callback style */
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_USERAGENT, "ws-data");
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_VERBOSE, 1L);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_USERAGENT, "ws-data");
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_VERBOSE, 1L);
     /* we want to send */
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_UPLOAD, 1L);
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_READFUNCTION, test_ws_data_m1_read);
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_READDATA, &m1_ctx);
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEFUNCTION,
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_UPLOAD, 1L);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_READFUNCTION, test_ws_data_m1_read);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_READDATA, &m1_ctx);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_WRITEFUNCTION,
                      test_ws_data_m1_write);
-    curl_easy_setopt(m1_ctx.easy, CURLOPT_WRITEDATA, &m1_ctx);
+    curl_easy_setopt(m1_ctx.curl, CURLOPT_WRITEDATA, &m1_ctx);
 
-    curl_multi_add_handle(multi, m1_ctx.easy);
+    curl_multi_add_handle(multi, m1_ctx.curl);
 
     while(1) {
       int still_running; /* keep number of running handles */
@@ -366,7 +366,7 @@ static CURLcode test_ws_data_m1_echo(const char *url,
 
     }
 
-    curl_multi_remove_handle(multi, m1_ctx.easy);
+    curl_multi_remove_handle(multi, m1_ctx.curl);
 
     /* check results */
     if(m1_ctx.frames_read < m1_ctx.nframes) {
@@ -386,8 +386,8 @@ static CURLcode test_ws_data_m1_echo(const char *url,
 out:
   if(multi)
     curl_multi_cleanup(multi);
-  if(m1_ctx.easy) {
-    curl_easy_cleanup(m1_ctx.easy);
+  if(m1_ctx.curl) {
+    curl_easy_cleanup(m1_ctx.curl);
   }
   free(m1_ctx.send_buf);
   free(m1_ctx.recv_buf);

tests/libtest/lib1485.c

@@ -26,7 +26,7 @@
 #include "memdebug.h"
 
 struct t1485_transfer_status {
-  CURL *easy;
+  CURL *curl;
   curl_off_t out_len;
   size_t hd_line;
   CURLcode result;
@@ -47,7 +47,7 @@ static size_t t1485_header_callback(char *ptr, size_t size, size_t nmemb,
     curl_off_t clen;
     long httpcode = 0;
     /* end of a response */
-    result = curl_easy_getinfo(st->easy, CURLINFO_RESPONSE_CODE, &httpcode);
+    result = curl_easy_getinfo(st->curl, CURLINFO_RESPONSE_CODE, &httpcode);
     curl_mfprintf(stderr, "header_callback, get status: %ld, %d\n",
                   httpcode, result);
     if(httpcode < 100 || httpcode >= 1000) {
@@ -57,7 +57,7 @@ static size_t t1485_header_callback(char *ptr, size_t size, size_t nmemb,
     }
     st->http_status = (int)httpcode;
     if(st->http_status >= 200 && st->http_status < 300) {
-      result = curl_easy_getinfo(st->easy, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T,
+      result = 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);
@@ -87,7 +87,7 @@ static size_t t1485_write_cb(char *ptr, size_t size, size_t nmemb, void *userp)
 
 static CURLcode test_lib1485(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   struct t1485_transfer_status st;
 
@@ -97,22 +97,22 @@ static CURLcode test_lib1485(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(curls);
-  st.easy = curls; /* to allow callbacks access */
+  easy_init(curl);
+  st.curl = curl; /* to allow callbacks access */
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1485_write_cb);
-  easy_setopt(curls, CURLOPT_WRITEDATA, &st);
-  easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1485_header_callback);
-  easy_setopt(curls, CURLOPT_HEADERDATA, &st);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1485_write_cb);
+  easy_setopt(curl, CURLOPT_WRITEDATA, &st);
+  easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1485_header_callback);
+  easy_setopt(curl, CURLOPT_HEADERDATA, &st);
 
-  easy_setopt(curls, CURLOPT_NOPROGRESS, 1L);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
 
-  res = curl_easy_perform(curls);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
 
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res; /* return the final return code */

tests/libtest/lib1500.c

@@ -27,7 +27,7 @@
 
 static CURLcode test_lib1500(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   int still_running;
   CURLcode i = TEST_ERR_FAILURE;
@@ -40,12 +40,12 @@ static CURLcode test_lib1500(const char *URL)
 
   multi_init(multi);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
 
-  multi_add_handle(multi, curls);
+  multi_add_handle(multi, curl);
 
   multi_perform(multi, &still_running);
 
@@ -79,7 +79,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UA */
 
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   if(res)

tests/libtest/lib1501.c

@@ -32,8 +32,8 @@ static CURLcode test_lib1501(const char *URL)
      conservative to allow old and slow machines to run this test too */
   static const int MAX_BLOCKED_TIME_MS = 500;
 
-  CURL *handle = NULL;
-  CURLM *mhandle = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int still_running = 0;
 
@@ -41,16 +41,16 @@ static CURLcode test_lib1501(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(handle);
+  easy_init(curl);
 
-  easy_setopt(handle, CURLOPT_URL, URL);
-  easy_setopt(handle, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_init(mhandle);
+  multi_init(multi);
 
-  multi_add_handle(mhandle, handle);
+  multi_add_handle(multi, curl);
 
-  multi_perform(mhandle, &still_running);
+  multi_perform(multi, &still_running);
 
   abort_on_test_timeout_custom(HANG_TIMEOUT);
 
@@ -71,7 +71,7 @@ static CURLcode test_lib1501(const char *URL)
     FD_ZERO(&fdwrite);
     FD_ZERO(&fdexcep);
 
-    multi_fdset(mhandle, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -82,7 +82,7 @@ static CURLcode test_lib1501(const char *URL)
     curl_mfprintf(stderr, "ping\n");
     before = curlx_now();
 
-    multi_perform(mhandle, &still_running);
+    multi_perform(multi, &still_running);
 
     abort_on_test_timeout_custom(HANG_TIMEOUT);
 
@@ -100,8 +100,8 @@ test_cleanup:
 
   /* undocumented cleanup sequence - type UA */
 
-  curl_multi_cleanup(mhandle);
-  curl_easy_cleanup(handle);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1502.c

@@ -35,8 +35,8 @@
 
 static CURLcode test_lib1502(const char *URL)
 {
-  CURL *easy = NULL;
-  CURL *dup;
+  CURL *curl = NULL;
+  CURL *curldupe;
   CURLM *multi = NULL;
   int still_running;
   CURLcode res = CURLE_OK;
@@ -62,27 +62,27 @@ static CURLcode test_lib1502(const char *URL)
     return TEST_ERR_MAJOR_BAD;
   }
 
-  easy_init(easy);
+  easy_init(curl);
 
-  easy_setopt(easy, CURLOPT_URL, URL);
-  easy_setopt(easy, CURLOPT_HEADER, 1L);
-  easy_setopt(easy, CURLOPT_RESOLVE, dns_cache_list);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_RESOLVE, dns_cache_list);
 
-  dup = curl_easy_duphandle(easy);
-  if(dup) {
-    curl_easy_cleanup(easy);
-    easy = dup;
+  curldupe = curl_easy_duphandle(curl);
+  if(curldupe) {
+    curl_easy_cleanup(curl);
+    curl = curldupe;
   }
   else {
     curl_slist_free_all(dns_cache_list);
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
     curl_global_cleanup();
     return CURLE_OUT_OF_MEMORY;
   }
 
   multi_init(multi);
 
-  multi_add_handle(multi, easy);
+  multi_add_handle(multi, curl);
 
   multi_perform(multi, &still_running);
 
@@ -121,26 +121,26 @@ test_cleanup:
   default:
     /* undocumented cleanup sequence - type UA */
     curl_multi_cleanup(multi);
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
     curl_global_cleanup();
     break;
   case 1503:
     /* proper cleanup sequence - type PA */
-    curl_multi_remove_handle(multi, easy);
+    curl_multi_remove_handle(multi, curl);
     curl_multi_cleanup(multi);
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
     curl_global_cleanup();
     break;
   case 1504:
     /* undocumented cleanup sequence - type UB */
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
     curl_multi_cleanup(multi);
     curl_global_cleanup();
     break;
   case 1505:
     /* proper cleanup sequence - type PB */
-    curl_multi_remove_handle(multi, easy);
-    curl_easy_cleanup(easy);
+    curl_multi_remove_handle(multi, curl);
+    curl_easy_cleanup(curl);
     curl_multi_cleanup(multi);
     curl_global_cleanup();
     break;

tests/libtest/lib1506.c

@@ -30,7 +30,7 @@ static CURLcode test_lib1506(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl[NUM_HANDLES] = {0};
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   size_t i;
   char target_url[256];
   char dnsentry[256];
@@ -57,9 +57,9 @@ static CURLcode test_lib1506(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_MAXCONNECTS, 3L);
+  multi_setopt(multi, CURLMOPT_MAXCONNECTS, 3L);
 
   /* get each easy handle */
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
@@ -83,7 +83,7 @@ static CURLcode test_lib1506(const char *URL)
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
     /* add handle to multi */
-    multi_add_handle(m, curl[i]);
+    multi_add_handle(multi, curl[i]);
 
     for(;;) {
       struct timeval interval;
@@ -93,7 +93,7 @@ static CURLcode test_lib1506(const char *URL)
       interval.tv_sec = 1;
       interval.tv_usec = 0;
 
-      multi_perform(m, &running);
+      multi_perform(multi, &running);
 
       abort_on_test_timeout();
 
@@ -104,7 +104,7 @@ static CURLcode test_lib1506(const char *URL)
       FD_ZERO(&wr);
       FD_ZERO(&exc);
 
-      multi_fdset(m, &rd, &wr, &exc, &maxfd);
+      multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
       /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -120,13 +120,13 @@ test_cleanup:
   /* proper cleanup sequence - type PB */
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
-    curl_multi_remove_handle(m, curl[i]);
+    curl_multi_remove_handle(multi, curl[i]);
     curl_easy_cleanup(curl[i]);
   }
 
   curl_slist_free_all(slist);
 
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1507.c

@@ -40,7 +40,7 @@ static CURLcode test_lib1507(const char *URL)
 
   CURLcode res = CURLE_OK;
   CURL *curl = NULL;
-  CURLM *mcurl = NULL;
+  CURLM *multi = NULL;
   int still_running = 1;
   struct curltime mp_start;
   struct curl_slist *rcpt_list = NULL;
@@ -49,7 +49,7 @@ static CURLcode test_lib1507(const char *URL)
 
   easy_init(curl);
 
-  multi_init(mcurl);
+  multi_init(multi);
 
   rcpt_list = curl_slist_append(rcpt_list, "<1507-recipient@example.com>");
 #if 0
@@ -66,12 +66,12 @@ static CURLcode test_lib1507(const char *URL)
   curl_easy_setopt(curl, CURLOPT_MAIL_FROM, "<1507-realuser@example.com>");
   curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, rcpt_list);
   curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
-  multi_add_handle(mcurl, curl);
+  multi_add_handle(multi, curl);
 
   mp_start = curlx_now();
 
   /* we start some action by calling perform right away */
-  curl_multi_perform(mcurl, &still_running);
+  curl_multi_perform(multi, &still_running);
 
   while(still_running) {
     struct timeval timeout;
@@ -92,7 +92,7 @@ static CURLcode test_lib1507(const char *URL)
     timeout.tv_sec = 1;
     timeout.tv_usec = 0;
 
-    curl_multi_timeout(mcurl, &curl_timeo);
+    curl_multi_timeout(multi, &curl_timeo);
     if(curl_timeo >= 0) {
       curlx_mstotv(&timeout, curl_timeo);
       if(timeout.tv_sec > 1) {
@@ -102,7 +102,7 @@ static CURLcode test_lib1507(const char *URL)
     }
 
     /* get file descriptors from the transfers */
-    curl_multi_fdset(mcurl, &fdread, &fdwrite, &fdexcep, &maxfd);
+    curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* In a real-world program you OF COURSE check the return code of the
        function calls.  On success, the value of maxfd is guaranteed to be
@@ -124,7 +124,7 @@ static CURLcode test_lib1507(const char *URL)
       break;
     case 0: /* timeout */
     default: /* action */
-      curl_multi_perform(mcurl, &still_running);
+      curl_multi_perform(multi, &still_running);
       break;
     }
   }
@@ -132,8 +132,8 @@ static CURLcode test_lib1507(const char *URL)
 test_cleanup:
 
   curl_slist_free_all(rcpt_list);
-  curl_multi_remove_handle(mcurl, curl);
-  curl_multi_cleanup(mcurl);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
   curl_easy_cleanup(curl);
   curl_global_cleanup();
 

tests/libtest/lib1508.c

@@ -28,19 +28,19 @@
 static CURLcode test_lib1508(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
 
   (void)URL;
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(m);
+  multi_init(multi);
 
 test_cleanup:
 
   /* proper cleanup sequence - type PB */
 
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   curl_mprintf("We are done\n");

tests/libtest/lib1515.c

@@ -35,9 +35,10 @@
 
 #define DNS_TIMEOUT 1L
 
-static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve)
+static CURLcode do_one_request(CURLM *multi, const char *URL,
+                               const char *resolve)
 {
-  CURL *curls;
+  CURL *curl;
   struct curl_slist *resolve_list = NULL;
   int still_running;
   CURLcode res = CURLE_OK;
@@ -46,20 +47,20 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve)
 
   resolve_list = curl_slist_append(resolve_list, resolve);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_RESOLVE, resolve_list);
-  easy_setopt(curls, CURLOPT_DNS_CACHE_TIMEOUT, DNS_TIMEOUT);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_RESOLVE, resolve_list);
+  easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, DNS_TIMEOUT);
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
-  easy_setopt(curls, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_add_handle(m, curls);
-  multi_perform(m, &still_running);
+  multi_add_handle(multi, curl);
+  multi_perform(multi, &still_running);
 
   abort_on_test_timeout();
 
@@ -74,18 +75,18 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve)
     timeout.tv_sec = 1;
     timeout.tv_usec = 0;
 
-    multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
     select_test(maxfd + 1, &fdread, &fdwrite, &fdexcep, &timeout);
 
     abort_on_test_timeout();
-    multi_perform(m, &still_running);
+    multi_perform(multi, &still_running);
 
     abort_on_test_timeout();
   }
 
   do {
-    msg = curl_multi_info_read(m, &msgs_left);
-    if(msg && msg->msg == CURLMSG_DONE && msg->easy_handle == curls) {
+    msg = curl_multi_info_read(multi, &msgs_left);
+    if(msg && msg->msg == CURLMSG_DONE && msg->easy_handle == curl) {
       res = msg->data.result;
       break;
     }
@@ -93,8 +94,8 @@ static CURLcode do_one_request(CURLM *m, const char *URL, const char *resolve)
 
 test_cleanup:
 
-  curl_multi_remove_handle(m, curls);
-  curl_easy_cleanup(curls);
+  curl_multi_remove_handle(multi, curl);
+  curl_easy_cleanup(curl);
   curl_slist_free_all(resolve_list);
 
   return res;

tests/libtest/lib1523.c

@@ -46,37 +46,37 @@ static size_t t1523_write_cb(char *d, size_t n, size_t l, void *p)
   return n*l;
 }
 
-static CURLcode run(CURL *hnd, long limit, long time)
+static CURLcode run(CURL *curl, long limit, long time)
 {
-  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_LIMIT, limit);
-  curl_easy_setopt(hnd, CURLOPT_LOW_SPEED_TIME, time);
-  return curl_easy_perform(hnd);
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, limit);
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, time);
+  return curl_easy_perform(curl);
 }
 
 static CURLcode test_lib1523(const char *URL)
 {
   CURLcode ret;
-  CURL *hnd;
+  CURL *curl;
   char buffer[CURL_ERROR_SIZE];
   curl_global_init(CURL_GLOBAL_ALL);
-  hnd = curl_easy_init();
-  curl_easy_setopt(hnd, CURLOPT_URL, URL);
-  curl_easy_setopt(hnd, CURLOPT_WRITEFUNCTION, t1523_write_cb);
-  curl_easy_setopt(hnd, CURLOPT_ERRORBUFFER, buffer);
-  curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 0L);
-  curl_easy_setopt(hnd, CURLOPT_XFERINFOFUNCTION, dload_progress_cb);
+  curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1523_write_cb);
+  curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, buffer);
+  curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
+  curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, dload_progress_cb);
 
-  ret = run(hnd, 1, 2);
+  ret = run(curl, 1, 2);
   if(ret)
     curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
 
-  ret = run(hnd, 12000, 1);
+  ret = run(curl, 12000, 1);
   if(ret != CURLE_OPERATION_TIMEDOUT)
     curl_mfprintf(stderr, "error (%d) %s\n", ret, buffer);
   else
     ret = CURLE_OK;
 
-  curl_easy_cleanup(hnd);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return ret;

tests/libtest/lib1531.c

@@ -30,8 +30,8 @@ static CURLcode test_lib1531(const char *URL)
   static char const testData[] = ".abc\0xyz";
   static curl_off_t const testDataSize = sizeof(testData) - 1;
 
-  CURL *easy;
-  CURLM *multi_handle;
+  CURL *curl;
+  CURLM *multi;
   int still_running; /* keep number of running handles */
   CURLMsg *msg; /* for picking up messages with the transfer status */
   int msgs_left; /* how many messages are left */
@@ -42,21 +42,21 @@ static CURLcode test_lib1531(const char *URL)
   global_init(CURL_GLOBAL_ALL);
 
   /* Allocate one curl handle per transfer */
-  easy = curl_easy_init();
+  curl = curl_easy_init();
 
   /* init a multi stack */
-  multi_handle = curl_multi_init();
+  multi = curl_multi_init();
 
   /* add the individual transfer */
-  curl_multi_add_handle(multi_handle, easy);
+  curl_multi_add_handle(multi, curl);
 
   /* set the options (I left out a few, you'll get the point anyway) */
-  curl_easy_setopt(easy, CURLOPT_URL, URL);
-  curl_easy_setopt(easy, CURLOPT_POSTFIELDSIZE_LARGE, testDataSize);
-  curl_easy_setopt(easy, CURLOPT_POSTFIELDS, testData);
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, testDataSize);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, testData);
 
   /* we start some action by calling perform right away */
-  curl_multi_perform(multi_handle, &still_running);
+  curl_multi_perform(multi, &still_running);
 
   abort_on_test_timeout();
 
@@ -80,7 +80,7 @@ static CURLcode test_lib1531(const char *URL)
     timeout.tv_sec = 1;
     timeout.tv_usec = 0;
 
-    curl_multi_timeout(multi_handle, &curl_timeo);
+    curl_multi_timeout(multi, &curl_timeo);
     if(curl_timeo >= 0) {
       curlx_mstotv(&timeout, curl_timeo);
       if(timeout.tv_sec > 1) {
@@ -90,7 +90,7 @@ static CURLcode test_lib1531(const char *URL)
     }
 
     /* get file descriptors from the transfers */
-    mc = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+    mc = curl_multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     if(mc != CURLM_OK) {
       curl_mfprintf(stderr, "curl_multi_fdset() failed, code %d.\n", mc);
@@ -118,7 +118,7 @@ static CURLcode test_lib1531(const char *URL)
       break;
     case 0: /* timeout */
     default: /* action */
-      curl_multi_perform(multi_handle, &still_running);
+      curl_multi_perform(multi, &still_running);
       break;
     }
 
@@ -127,7 +127,7 @@ static CURLcode test_lib1531(const char *URL)
 
   /* See how the transfers went */
   do {
-    msg = curl_multi_info_read(multi_handle, &msgs_left);
+    msg = curl_multi_info_read(multi, &msgs_left);
     if(msg && msg->msg == CURLMSG_DONE) {
       curl_mprintf("HTTP transfer completed with status %d\n",
                    msg->data.result);
@@ -138,10 +138,10 @@ static CURLcode test_lib1531(const char *URL)
   } while(msg);
 
 test_cleanup:
-  curl_multi_cleanup(multi_handle);
+  curl_multi_cleanup(multi);
 
   /* Free the curl handles */
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1533.c

@@ -34,7 +34,7 @@
 #include "memdebug.h"
 
 struct cb_data {
-  CURL *easy_handle;
+  CURL *curl;
   int response_received;
   int paused;
   size_t remaining_bytes;
@@ -42,7 +42,7 @@ struct cb_data {
 
 static void reset_data(struct cb_data *data, CURL *curl)
 {
-  data->easy_handle = curl;
+  data->curl = curl;
   data->response_received = 0;
   data->paused = 0;
   data->remaining_bytes = 3;
@@ -85,7 +85,7 @@ static size_t t1533_write_cb(char *ptr, size_t size, size_t nmemb, void *userp)
   if(data->paused) {
     /* continue to send request body data */
     data->paused = 0;
-    curl_easy_pause(data->easy_handle, CURLPAUSE_CONT);
+    curl_easy_pause(data->curl, CURLPAUSE_CONT);
   }
 
   return totalsize;

tests/libtest/lib1540.c

@@ -27,7 +27,7 @@
 #include "memdebug.h"
 
 struct t1540_transfer_status {
-  CURL *easy;
+  CURL *curl;
   int halted;
   int counter; /* count write callback invokes */
   int please;  /* number of times xferinfo is called while halted */
@@ -48,7 +48,7 @@ static int please_continue(void *userp,
     st->please++;
     if(st->please == 2) {
       /* waited enough, unpause! */
-      curl_easy_pause(st->easy, CURLPAUSE_CONT);
+      curl_easy_pause(st->curl, CURLPAUSE_CONT);
     }
   }
   curl_mfprintf(stderr, "xferinfo: paused %d\n", st->halted);
@@ -83,7 +83,7 @@ static size_t t1540_write_cb(char *ptr, size_t size, size_t nmemb, void *userp)
 
 static CURLcode test_lib1540(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   struct t1540_transfer_status st;
 
@@ -93,30 +93,30 @@ static CURLcode test_lib1540(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(curls);
-  st.easy = curls; /* to allow callbacks access */
+  easy_init(curl);
+  st.curl = curl; /* to allow callbacks access */
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1540_write_cb);
-  easy_setopt(curls, CURLOPT_WRITEDATA, &st);
-  easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1540_header_callback);
-  easy_setopt(curls, CURLOPT_HEADERDATA, &st);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1540_write_cb);
+  easy_setopt(curl, CURLOPT_WRITEDATA, &st);
+  easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1540_header_callback);
+  easy_setopt(curl, CURLOPT_HEADERDATA, &st);
 
-  easy_setopt(curls, CURLOPT_XFERINFOFUNCTION, please_continue);
-  easy_setopt(curls, CURLOPT_XFERINFODATA, &st);
-  easy_setopt(curls, CURLOPT_NOPROGRESS, 0L);
+  easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, please_continue);
+  easy_setopt(curl, CURLOPT_XFERINFODATA, &st);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
-  test_setopt(curls, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
+  test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  res = curl_easy_perform(curls);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
 
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res; /* return the final return code */

tests/libtest/lib1541.c

@@ -26,7 +26,7 @@
 #include "memdebug.h"
 
 struct t1541_transfer_status {
-  CURL *easy;
+  CURL *curl;
   int hd_count;
   int bd_count;
   CURLcode result;
@@ -50,11 +50,11 @@ static void report_time(const char *key, const char *where, curl_off_t time,
                  key, where, time);
 }
 
-static void check_time(CURL *easy, int key, const char *name,
+static void check_time(CURL *curl, int key, const char *name,
                        const char *where)
 {
   curl_off_t tval;
-  CURLcode res = curl_easy_getinfo(easy, (CURLINFO)key, &tval);
+  CURLcode res = curl_easy_getinfo(curl, (CURLINFO)key, &tval);
   if(res) {
     t1541_geterr(name, res, __LINE__);
   }
@@ -62,11 +62,11 @@ static void check_time(CURL *easy, int key, const char *name,
     report_time(name, where, tval, tval > 0);
 }
 
-static void check_time0(CURL *easy, int key, const char *name,
+static void check_time0(CURL *curl, int key, const char *name,
                         const char *where)
 {
   curl_off_t tval;
-  CURLcode res = curl_easy_getinfo(easy, (CURLINFO)key, &tval);
+  CURLcode res = curl_easy_getinfo(curl, (CURLINFO)key, &tval);
   if(res) {
     t1541_geterr(name, res, __LINE__);
   }
@@ -83,15 +83,15 @@ static size_t t1541_header_callback(char *ptr, size_t size, size_t nmemb,
   (void)ptr;
   if(!st->hd_count++) {
     /* first header, check some CURLINFO value to be reported. See #13125 */
-    check_time(st->easy, KN(CURLINFO_CONNECT_TIME_T), "1st header");
-    check_time(st->easy, KN(CURLINFO_PRETRANSFER_TIME_T), "1st header");
-    check_time(st->easy, KN(CURLINFO_STARTTRANSFER_TIME_T), "1st header");
+    check_time(st->curl, KN(CURLINFO_CONNECT_TIME_T), "1st header");
+    check_time(st->curl, KN(CURLINFO_PRETRANSFER_TIME_T), "1st header");
+    check_time(st->curl, KN(CURLINFO_STARTTRANSFER_TIME_T), "1st header");
     /* continuously updated */
-    check_time(st->easy, KN(CURLINFO_TOTAL_TIME_T), "1st header");
+    check_time(st->curl, KN(CURLINFO_TOTAL_TIME_T), "1st header");
     /* no SSL, must be 0 */
-    check_time0(st->easy, KN(CURLINFO_APPCONNECT_TIME_T), "1st header");
+    check_time0(st->curl, KN(CURLINFO_APPCONNECT_TIME_T), "1st header");
     /* download not really started */
-    check_time0(st->easy, KN(CURLINFO_SPEED_DOWNLOAD_T), "1st header");
+    check_time0(st->curl, KN(CURLINFO_SPEED_DOWNLOAD_T), "1st header");
   }
   (void)fwrite(ptr, size, nmemb, stdout);
   return len;
@@ -109,7 +109,7 @@ static size_t t1541_write_cb(char *ptr, size_t size, size_t nmemb, void *userp)
 
 static CURLcode test_lib1541(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   struct t1541_transfer_status st;
 
@@ -119,31 +119,31 @@ static CURLcode test_lib1541(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(curls);
-  st.easy = curls; /* to allow callbacks access */
+  easy_init(curl);
+  st.curl = curl; /* to allow callbacks access */
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_WRITEFUNCTION, t1541_write_cb);
-  easy_setopt(curls, CURLOPT_WRITEDATA, &st);
-  easy_setopt(curls, CURLOPT_HEADERFUNCTION, t1541_header_callback);
-  easy_setopt(curls, CURLOPT_HEADERDATA, &st);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1541_write_cb);
+  easy_setopt(curl, CURLOPT_WRITEDATA, &st);
+  easy_setopt(curl, CURLOPT_HEADERFUNCTION, t1541_header_callback);
+  easy_setopt(curl, CURLOPT_HEADERDATA, &st);
 
-  easy_setopt(curls, CURLOPT_NOPROGRESS, 0L);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
 
-  res = curl_easy_perform(curls);
+  res = curl_easy_perform(curl);
 
-  check_time(curls, KN(CURLINFO_CONNECT_TIME_T), "done");
-  check_time(curls, KN(CURLINFO_PRETRANSFER_TIME_T), "done");
-  check_time(curls, KN(CURLINFO_POSTTRANSFER_TIME_T), "done");
-  check_time(curls, KN(CURLINFO_STARTTRANSFER_TIME_T), "done");
+  check_time(curl, KN(CURLINFO_CONNECT_TIME_T), "done");
+  check_time(curl, KN(CURLINFO_PRETRANSFER_TIME_T), "done");
+  check_time(curl, KN(CURLINFO_POSTTRANSFER_TIME_T), "done");
+  check_time(curl, KN(CURLINFO_STARTTRANSFER_TIME_T), "done");
   /* no SSL, must be 0 */
-  check_time0(curls, KN(CURLINFO_APPCONNECT_TIME_T), "done");
-  check_time(curls, KN(CURLINFO_SPEED_DOWNLOAD_T), "done");
-  check_time(curls, KN(CURLINFO_TOTAL_TIME_T), "done");
+  check_time0(curl, KN(CURLINFO_APPCONNECT_TIME_T), "done");
+  check_time(curl, KN(CURLINFO_SPEED_DOWNLOAD_T), "done");
+  check_time(curl, KN(CURLINFO_TOTAL_TIME_T), "done");
 
 test_cleanup:
 
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res; /* return the final return code */

tests/libtest/lib1542.c

@@ -37,26 +37,26 @@
 
 static CURLcode test_lib1542(const char *URL)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
 
   global_init(CURL_GLOBAL_ALL);
 
-  res_easy_init(easy);
+  res_easy_init(curl);
 
-  easy_setopt(easy, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = FALSE;
-  easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
@@ -64,19 +64,19 @@ static CURLcode test_lib1542(const char *URL)
    * seconds old */
   curlx_wait_ms(2000);
 
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  easy_setopt(easy, CURLOPT_MAXLIFETIME_CONN, 1L);
+  easy_setopt(curl, CURLOPT_MAXLIFETIME_CONN, 1L);
 
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
 test_cleanup:
 
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1545.c

@@ -25,27 +25,27 @@
 
 static CURLcode test_lib1545(const char *URL)
 {
-  CURL *eh = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   struct curl_httppost *lastptr = NULL;
   struct curl_httppost *m_formpost = NULL;
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(eh);
+  easy_init(curl);
 
-  easy_setopt(eh, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
   curl_formadd(&m_formpost, &lastptr, CURLFORM_COPYNAME, "file",
                CURLFORM_FILE, "missing-file", CURLFORM_END);
-  curl_easy_setopt(eh, CURLOPT_HTTPPOST, m_formpost);
+  curl_easy_setopt(curl, CURLOPT_HTTPPOST, m_formpost);
 
-  (void)curl_easy_perform(eh);
-  (void)curl_easy_perform(eh);
+  (void)curl_easy_perform(curl);
+  (void)curl_easy_perform(curl);
 
 test_cleanup:
 
   curl_formfree(m_formpost);
-  curl_easy_cleanup(eh);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1550.c

@@ -29,7 +29,7 @@
 
 static CURLcode test_lib1550(const char *URL)
 {
-  CURLM *handle;
+  CURLM *multi;
   CURLcode res = CURLE_OK;
   static const char * const bl_servers[] =
      {"Microsoft-IIS/6.0", "nginx/0.8.54", NULL};
@@ -37,12 +37,12 @@ static CURLcode test_lib1550(const char *URL)
      {"curl.se:443", "example.com:80", NULL};
 
   global_init(CURL_GLOBAL_ALL);
-  handle = curl_multi_init();
+  multi = curl_multi_init();
   (void)URL;
 
-  curl_multi_setopt(handle, CURLMOPT_PIPELINING_SERVER_BL, bl_servers);
-  curl_multi_setopt(handle, CURLMOPT_PIPELINING_SITE_BL, bl_sites);
-  curl_multi_cleanup(handle);
+  curl_multi_setopt(multi, CURLMOPT_PIPELINING_SERVER_BL, bl_servers);
+  curl_multi_setopt(multi, CURLMOPT_PIPELINING_SITE_BL, bl_sites);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
   return CURLE_OK;
 }

tests/libtest/lib1552.c

@@ -27,7 +27,7 @@
 
 static CURLcode test_lib1552(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   int still_running;
   CURLcode i = CURLE_OK;
@@ -41,14 +41,14 @@ static CURLcode test_lib1552(const char *URL)
 
   multi_init(multi);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_HEADER, 1L);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
-  easy_setopt(curls, CURLOPT_USERPWD, "u:s");
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_USERPWD, "u:s");
 
-  multi_add_handle(multi, curls);
+  multi_add_handle(multi, curl);
 
   multi_perform(multi, &still_running);
 
@@ -82,7 +82,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UA */
 
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   if(res)

tests/libtest/lib1553.c

@@ -41,7 +41,7 @@ static int t1553_xferinfo(void *p,
 
 static CURLcode test_lib1553(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   int still_running;
   CURLcode i = CURLE_OK;
@@ -56,28 +56,28 @@ static CURLcode test_lib1553(const char *URL)
 
   multi_init(multi);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  mime = curl_mime_init(curls);
+  mime = curl_mime_init(curl);
   field = curl_mime_addpart(mime);
   curl_mime_name(field, "name");
   curl_mime_data(field, "value", CURL_ZERO_TERMINATED);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_HEADER, 1L);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
-  easy_setopt(curls, CURLOPT_MIMEPOST, mime);
-  easy_setopt(curls, CURLOPT_USERPWD, "u:s");
-  easy_setopt(curls, CURLOPT_XFERINFOFUNCTION, t1553_xferinfo);
-  easy_setopt(curls, CURLOPT_NOPROGRESS, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+  easy_setopt(curl, CURLOPT_USERPWD, "u:s");
+  easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, t1553_xferinfo);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
-  test_setopt(curls, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(curls, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
+  test_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_add_handle(multi, curls);
+  multi_add_handle(multi, curl);
 
   multi_perform(multi, &still_running);
 
@@ -103,9 +103,9 @@ static CURLcode test_lib1553(const char *URL)
 test_cleanup:
 
   curl_mime_free(mime);
-  curl_multi_remove_handle(multi, curls);
+  curl_multi_remove_handle(multi, curl);
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   if(res)

tests/libtest/lib1554.c

@@ -37,19 +37,19 @@ static const char *ldata_names[] = {
   "NULL",
 };
 
-static void t1554_test_lock(CURL *handle, curl_lock_data data,
+static void t1554_test_lock(CURL *curl, curl_lock_data data,
                             curl_lock_access laccess, void *useptr)
 {
-  (void)handle;
+  (void)curl;
   (void)data;
   (void)laccess;
   (void)useptr;
   curl_mprintf("-> Mutex lock %s\n", ldata_names[data]);
 }
 
-static void t1554_test_unlock(CURL *handle, curl_lock_data data, void *useptr)
+static void t1554_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
 {
-  (void)handle;
+  (void)curl;
   (void)data;
   (void)useptr;
   curl_mprintf("<- Mutex unlock %s\n", ldata_names[data]);

tests/libtest/lib1557.c

@@ -27,7 +27,7 @@
 
 static CURLcode test_lib1557(const char *URL)
 {
-  CURLM *curlm = NULL;
+  CURLM *multi = NULL;
   CURL *curl1 = NULL;
   CURL *curl2 = NULL;
   int running_handles = 0;
@@ -35,28 +35,28 @@ static CURLcode test_lib1557(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(curlm);
-  multi_setopt(curlm, CURLMOPT_MAX_HOST_CONNECTIONS, 1L);
+  multi_init(multi);
+  multi_setopt(multi, CURLMOPT_MAX_HOST_CONNECTIONS, 1L);
 
   easy_init(curl1);
   easy_setopt(curl1, CURLOPT_URL, URL);
-  multi_add_handle(curlm, curl1);
+  multi_add_handle(multi, curl1);
 
   easy_init(curl2);
   easy_setopt(curl2, CURLOPT_URL, URL);
-  multi_add_handle(curlm, curl2);
+  multi_add_handle(multi, curl2);
 
-  multi_perform(curlm, &running_handles);
+  multi_perform(multi, &running_handles);
 
-  multi_remove_handle(curlm, curl2);
+  multi_remove_handle(multi, curl2);
 
   /* If curl2 is still in the connect-pending list, this will crash */
-  multi_remove_handle(curlm, curl1);
+  multi_remove_handle(multi, curl1);
 
 test_cleanup:
   curl_easy_cleanup(curl1);
   curl_easy_cleanup(curl2);
-  curl_multi_cleanup(curlm);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib1565.c

@@ -32,7 +32,7 @@
 #define TIME_BETWEEN_START_SECS 2
 
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
-static CURL *pending_handles[CONN_NUM];
+static CURL *pending_curls[CONN_NUM];
 static int pending_num = 0;
 static CURLcode t1565_test_failure = CURLE_OK;
 
@@ -41,7 +41,7 @@ static const char *t1565_url;
 
 static void *t1565_run_thread(void *ptr)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   int i;
 
@@ -50,10 +50,10 @@ static void *t1565_run_thread(void *ptr)
   for(i = 0; i < CONN_NUM; i++) {
     curlx_wait_ms(TIME_BETWEEN_START_SECS * 1000);
 
-    easy_init(easy);
+    easy_init(curl);
 
-    easy_setopt(easy, CURLOPT_URL, t1565_url);
-    easy_setopt(easy, CURLOPT_VERBOSE, 0L);
+    easy_setopt(curl, CURLOPT_URL, t1565_url);
+    easy_setopt(curl, CURLOPT_VERBOSE, 0L);
 
     pthread_mutex_lock(&lock);
 
@@ -62,9 +62,9 @@ static void *t1565_run_thread(void *ptr)
       goto test_cleanup;
     }
 
-    pending_handles[pending_num] = easy;
+    pending_curls[pending_num] = curl;
     pending_num++;
-    easy = NULL;
+    curl = NULL;
 
     pthread_mutex_unlock(&lock);
 
@@ -73,7 +73,7 @@ static void *t1565_run_thread(void *ptr)
 
 test_cleanup:
 
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
 
   pthread_mutex_lock(&lock);
 
@@ -92,7 +92,7 @@ static CURLcode test_lib1565(const char *URL)
   int i;
   int result;
   CURLcode res = CURLE_OK;
-  CURL *started_handles[CONN_NUM];
+  CURL *started_curls[CONN_NUM];
   int started_num = 0;
   int finished_num = 0;
   pthread_t tid = 0;
@@ -150,13 +150,13 @@ static CURLcode test_lib1565(const char *URL)
     pthread_mutex_lock(&lock);
 
     while(pending_num > 0) {
-      res_multi_add_handle(testmulti, pending_handles[pending_num - 1]);
+      res_multi_add_handle(testmulti, pending_curls[pending_num - 1]);
       if(res) {
         pthread_mutex_unlock(&lock);
         goto test_cleanup;
       }
 
-      started_handles[started_num] = pending_handles[pending_num - 1];
+      started_curls[started_num] = pending_curls[pending_num - 1];
       started_num++;
       pending_num--;
     }
@@ -190,9 +190,9 @@ test_cleanup:
 
   curl_multi_cleanup(testmulti);
   for(i = 0; i < pending_num; i++)
-    curl_easy_cleanup(pending_handles[i]);
+    curl_easy_cleanup(pending_curls[i]);
   for(i = 0; i < started_num; i++)
-    curl_easy_cleanup(started_handles[i]);
+    curl_easy_cleanup(started_curls[i]);
   curl_global_cleanup();
 
   return t1565_test_failure;

tests/libtest/lib1568.c

@@ -28,23 +28,23 @@
 static CURLcode test_lib1568(const char *URL)
 {
   CURLcode ret;
-  CURL *hnd;
+  CURL *curl;
   curl_global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  curl_easy_setopt(hnd, CURLOPT_URL, URL);
-  curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-  curl_easy_setopt(hnd, CURLOPT_HEADER, 1L);
-  curl_easy_setopt(hnd, CURLOPT_USERPWD, "testuser:testpass");
-  curl_easy_setopt(hnd, CURLOPT_USERAGENT, "lib1568");
-  curl_easy_setopt(hnd, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
-  curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, 50L);
-  curl_easy_setopt(hnd, CURLOPT_PORT, atol(libtest_arg2));
+  curl = curl_easy_init();
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt(curl, CURLOPT_HEADER, 1L);
+  curl_easy_setopt(curl, CURLOPT_USERPWD, "testuser:testpass");
+  curl_easy_setopt(curl, CURLOPT_USERAGENT, "lib1568");
+  curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
+  curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
+  curl_easy_setopt(curl, CURLOPT_PORT, atol(libtest_arg2));
 
-  ret = curl_easy_perform(hnd);
+  ret = curl_easy_perform(curl);
 
-  curl_easy_cleanup(hnd);
-  hnd = NULL;
+  curl_easy_cleanup(curl);
+  curl = NULL;
 
   curl_global_cleanup();
   return ret;

tests/libtest/lib1569.c

@@ -28,23 +28,23 @@
 static CURLcode test_lib1569(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(hnd);
-  easy_setopt(hnd, CURLOPT_URL, URL);
-  easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-  easy_setopt(hnd, CURLOPT_HEADER, 1L);
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
 
-  res = curl_easy_perform(hnd);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  curl_easy_setopt(hnd, CURLOPT_URL, libtest_arg2);
-  res = curl_easy_perform(hnd);
+  curl_easy_setopt(curl, CURLOPT_URL, libtest_arg2);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
-  curl_easy_cleanup(hnd);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib1592.c

@@ -41,7 +41,7 @@
 static CURLcode test_lib1592(const char *URL)
 {
   int stillRunning;
-  CURLM *multiHandle = NULL;
+  CURLM *multi = NULL;
   CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   CURLMcode mres;
@@ -49,7 +49,7 @@ static CURLcode test_lib1592(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(multiHandle);
+  multi_init(multi);
 
   easy_init(curl);
 
@@ -88,17 +88,17 @@ static CURLcode test_lib1592(const char *URL)
      this. */
   easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout);
 
-  multi_add_handle(multiHandle, curl);
+  multi_add_handle(multi, curl);
 
   /* This should move the handle from INIT => CONNECT => WAITRESOLVE. */
   curl_mfprintf(stderr, "curl_multi_perform()...\n");
-  multi_perform(multiHandle, &stillRunning);
+  multi_perform(multi, &stillRunning);
   curl_mfprintf(stderr, "curl_multi_perform() succeeded\n");
 
   /* Start measuring how long it takes to remove the handle. */
   curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
   start_test_timing();
-  mres = curl_multi_remove_handle(multiHandle, curl);
+  mres = curl_multi_remove_handle(multi, curl);
   if(mres) {
     curl_mfprintf(stderr,
                   "curl_multi_remove_handle() failed, with code %d\n", mres);
@@ -114,7 +114,7 @@ static CURLcode test_lib1592(const char *URL)
 
 test_cleanup:
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(multiHandle);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1662.c

@@ -49,7 +49,7 @@ static size_t t1662_read_cb(char *ptr, size_t size, size_t nmemb, void *userp)
 static CURLcode test_lib1662(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   curl_mime *mime1;
   curl_mimepart *part1;
   struct t1662_WriteThis pooh = { 1 };
@@ -58,30 +58,30 @@ static CURLcode test_lib1662(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  if(hnd) {
-    curl_easy_setopt(hnd, CURLOPT_BUFFERSIZE, 102400L);
-    curl_easy_setopt(hnd, CURLOPT_URL, URL);
-    curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L);
-    mime1 = curl_mime_init(hnd);
+  curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 102400L);
+    curl_easy_setopt(curl, CURLOPT_URL, URL);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+    mime1 = curl_mime_init(curl);
     if(mime1) {
       part1 = curl_mime_addpart(mime1);
       curl_mime_data_cb(part1, -1, t1662_read_cb, NULL, NULL, &pooh);
       curl_mime_filename(part1, "poetry.txt");
       curl_mime_name(part1, "content");
-      curl_easy_setopt(hnd, CURLOPT_MIMEPOST, mime1);
-      curl_easy_setopt(hnd, CURLOPT_USERAGENT, "curl/2000");
-      curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L);
-      curl_easy_setopt(hnd, CURLOPT_MAXREDIRS, 50L);
-      curl_easy_setopt(hnd, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
-      curl_easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-      curl_easy_setopt(hnd, CURLOPT_FTP_SKIP_PASV_IP, 1L);
-      curl_easy_setopt(hnd, CURLOPT_TCP_KEEPALIVE, 1L);
-      res = curl_easy_perform(hnd);
+      curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime1);
+      curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/2000");
+      curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+      curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
+      curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
+      curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+      curl_easy_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, 1L);
+      curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
+      res = curl_easy_perform(curl);
     }
   }
 
-  curl_easy_cleanup(hnd);
+  curl_easy_cleanup(curl);
   curl_mime_free(mime1);
   curl_global_cleanup();
   return res;

tests/libtest/lib1900.c

@@ -28,26 +28,26 @@
 static CURLcode test_lib1900(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURL *hnd = NULL;
-  CURL *second = NULL;
+  CURL *curl1 = NULL;
+  CURL *curl2 = NULL;
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(hnd);
-  easy_setopt(hnd, CURLOPT_URL, URL);
-  easy_setopt(hnd, CURLOPT_HSTS, "first-hsts.txt");
-  easy_setopt(hnd, CURLOPT_HSTS, "second-hsts.txt");
+  easy_init(curl1);
+  easy_setopt(curl1, CURLOPT_URL, URL);
+  easy_setopt(curl1, CURLOPT_HSTS, "first-hsts.txt");
+  easy_setopt(curl1, CURLOPT_HSTS, "second-hsts.txt");
 
-  second = curl_easy_duphandle(hnd);
+  curl2 = curl_easy_duphandle(curl1);
 
-  curl_easy_cleanup(hnd);
-  curl_easy_cleanup(second);
+  curl_easy_cleanup(curl1);
+  curl_easy_cleanup(curl2);
   curl_global_cleanup();
   return CURLE_OK;
 
 test_cleanup:
-  curl_easy_cleanup(hnd);
-  curl_easy_cleanup(second);
+  curl_easy_cleanup(curl1);
+  curl_easy_cleanup(curl2);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib1903.c

@@ -28,26 +28,26 @@
 static CURLcode test_lib1903(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURL *ch = NULL;
+  CURL *curl = NULL;
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(ch);
+  easy_init(curl);
 
-  easy_setopt(ch, CURLOPT_URL, URL);
-  easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2);
-  res = curl_easy_perform(ch);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  curl_easy_reset(ch);
+  curl_easy_reset(curl);
 
-  easy_setopt(ch, CURLOPT_URL, URL);
-  easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2);
-  easy_setopt(ch, CURLOPT_COOKIEJAR, libtest_arg3);
-  res = curl_easy_perform(ch);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2);
+  easy_setopt(curl, CURLOPT_COOKIEJAR, libtest_arg3);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
-  curl_easy_cleanup(ch);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib1905.c

@@ -27,35 +27,35 @@
 
 static CURLcode test_lib1905(const char *URL)
 {
-  CURLSH *sh = NULL;
-  CURL *ch = NULL;
+  CURLSH *share = NULL;
+  CURL *curl = NULL;
   int unfinished;
-  CURLM *cm;
+  CURLM *multi;
 
   curl_global_init(CURL_GLOBAL_ALL);
 
-  cm = curl_multi_init();
-  if(!cm) {
+  multi = curl_multi_init();
+  if(!multi) {
     curl_global_cleanup();
     return TEST_ERR_MULTI;
   }
-  sh = curl_share_init();
-  if(!sh)
+  share = curl_share_init();
+  if(!share)
     goto cleanup;
 
-  curl_share_setopt(sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
-  curl_share_setopt(sh, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
+  curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
+  curl_share_setopt(share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
 
-  ch = curl_easy_init();
-  if(!ch)
+  curl = curl_easy_init();
+  if(!curl)
     goto cleanup;
 
-  curl_easy_setopt(ch, CURLOPT_SHARE, sh);
-  curl_easy_setopt(ch, CURLOPT_URL, URL);
-  curl_easy_setopt(ch, CURLOPT_COOKIEFILE, libtest_arg2);
-  curl_easy_setopt(ch, CURLOPT_COOKIEJAR, libtest_arg2);
+  curl_easy_setopt(curl, CURLOPT_SHARE, share);
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  curl_easy_setopt(curl, CURLOPT_COOKIEFILE, libtest_arg2);
+  curl_easy_setopt(curl, CURLOPT_COOKIEJAR, libtest_arg2);
 
-  curl_multi_add_handle(cm, ch);
+  curl_multi_add_handle(multi, curl);
 
   unfinished = 1;
   while(unfinished) {
@@ -67,10 +67,10 @@ static CURLcode test_lib1905(const char *URL)
     FD_ZERO(&R);
     FD_ZERO(&W);
     FD_ZERO(&E);
-    curl_multi_perform(cm, &unfinished);
+    curl_multi_perform(multi, &unfinished);
 
-    curl_multi_fdset(cm, &R, &W, &E, &MAX);
-    curl_multi_timeout(cm, &max_tout);
+    curl_multi_fdset(multi, &R, &W, &E, &MAX);
+    curl_multi_timeout(multi, &max_tout);
 
     if(max_tout > 0) {
       curlx_mstotv(&timeout, max_tout);
@@ -83,14 +83,14 @@ static CURLcode test_lib1905(const char *URL)
     select(MAX + 1, &R, &W, &E, &timeout);
   }
 
-  curl_easy_setopt(ch, CURLOPT_COOKIELIST, "FLUSH");
-  curl_easy_setopt(ch, CURLOPT_SHARE, NULL);
+  curl_easy_setopt(curl, CURLOPT_COOKIELIST, "FLUSH");
+  curl_easy_setopt(curl, CURLOPT_SHARE, NULL);
 
-  curl_multi_remove_handle(cm, ch);
+  curl_multi_remove_handle(multi, curl);
 cleanup:
-  curl_easy_cleanup(ch);
-  curl_share_cleanup(sh);
-  curl_multi_cleanup(cm);
+  curl_easy_cleanup(curl);
+  curl_share_cleanup(share);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return CURLE_OK;

tests/libtest/lib1908.c

@@ -28,34 +28,34 @@
 static CURLcode test_lib1908(const char *URL)
 {
   CURLcode ret = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   start_test_timing();
 
   curl_global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  if(hnd) {
-    curl_easy_setopt(hnd, CURLOPT_URL, URL);
-    curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L);
-    curl_easy_setopt(hnd, CURLOPT_ALTSVC, libtest_arg2);
-    ret = curl_easy_perform(hnd);
+  curl = curl_easy_init();
+  if(curl) {
+    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);
 
     if(!ret) {
       /* make a copy and check that this also has alt-svc activated */
-      CURL *also = curl_easy_duphandle(hnd);
-      if(also) {
-        ret = curl_easy_perform(also);
+      CURL *curldupe = curl_easy_duphandle(curl);
+      if(curldupe) {
+        ret = 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(also);
+        curl_easy_cleanup(curldupe);
       }
     }
 
-    curl_easy_reset(hnd);
+    curl_easy_reset(curl);
 
     /* using the same file name for the alt-svc cache, this clobbers the
-       content just written from the 'also' handle */
-    curl_easy_cleanup(hnd);
+       content just written from the 'curldupe' handle */
+    curl_easy_cleanup(curl);
   }
   curl_global_cleanup();
   return ret;

tests/libtest/lib1910.c

@@ -28,19 +28,19 @@
 static CURLcode test_lib1910(const char *URL)
 {
   CURLcode ret = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   start_test_timing();
 
   curl_global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  if(hnd) {
-    curl_easy_setopt(hnd, CURLOPT_URL, URL);
-    curl_easy_setopt(hnd, CURLOPT_NOPROGRESS, 1L);
-    curl_easy_setopt(hnd, CURLOPT_FOLLOWLOCATION, 1L);
-    curl_easy_setopt(hnd, CURLOPT_USERPWD, "user\nname:pass\nword");
-    ret = curl_easy_perform(hnd);
-    curl_easy_cleanup(hnd);
+  curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, URL);
+    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);
+    curl_easy_cleanup(curl);
   }
   curl_global_cleanup();
   return ret;

tests/libtest/lib1911.c

@@ -34,13 +34,13 @@ static CURLcode test_lib1911(const char *URL)
   static char testbuf[MAX_INPUT_LENGTH + 2];
 
   const struct curl_easyoption *o;
-  CURL *easy;
+  CURL *curl;
   int error = 0;
   (void)URL;
 
   curl_global_init(CURL_GLOBAL_ALL);
-  easy = curl_easy_init();
-  if(!easy) {
+  curl = curl_easy_init();
+  if(!curl) {
     curl_global_cleanup();
     return TEST_ERR_EASY_INIT;
   }
@@ -72,7 +72,7 @@ static CURLcode test_lib1911(const char *URL)
 
       /* This is a string. Make sure that passing in a string longer
          CURL_MAX_INPUT_LENGTH returns an error */
-      result = curl_easy_setopt(easy, o->id, testbuf);
+      result = curl_easy_setopt(curl, o->id, testbuf);
       switch(result) {
       case CURLE_BAD_FUNCTION_ARGUMENT: /* the most normal */
       case CURLE_UNKNOWN_OPTION: /* left out from the build */
@@ -88,7 +88,7 @@ static CURLcode test_lib1911(const char *URL)
       }
     }
   }
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return error == 0 ? CURLE_OK : TEST_ERR_FAILURE;
 }

tests/libtest/lib1913.c

@@ -28,20 +28,20 @@
 static CURLcode test_lib1913(const char *URL)
 {
   CURLcode ret = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   start_test_timing();
 
   curl_global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  if(hnd) {
-    curl_easy_setopt(hnd, CURLOPT_URL, URL);
-    curl_easy_setopt(hnd, CURLOPT_NOBODY, 1L);
+  curl = curl_easy_init();
+  if(curl) {
+    curl_easy_setopt(curl, CURLOPT_URL, URL);
+    curl_easy_setopt(curl, CURLOPT_NOBODY, 1L);
     if(libtest_arg2)
       /* test1914 sets this extra arg */
-      curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L);
-    ret = curl_easy_perform(hnd);
-    curl_easy_cleanup(hnd);
+      curl_easy_setopt(curl, CURLOPT_FILETIME, 1L);
+    ret = curl_easy_perform(curl);
+    curl_easy_cleanup(curl);
   }
   curl_global_cleanup();
   return ret;

tests/libtest/lib1915.c

@@ -31,7 +31,7 @@ struct state {
 };
 
 /* "read" is from the point of the library, it wants data from us */
-static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e,
+static CURLSTScode hstsread(CURL *curl, struct curl_hstsentry *e,
                             void *userp)
 {
   struct entry {
@@ -56,7 +56,7 @@ static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e,
   const char *host;
   const char *expire;
   struct state *s = (struct state *)userp;
-  (void)easy;
+  (void)curl;
   host = preload_hosts[s->index].name;
   expire = preload_hosts[s->index++].exp;
 
@@ -72,20 +72,20 @@ static CURLSTScode hstsread(CURL *easy, struct curl_hstsentry *e,
 }
 
 /* verify error from callback */
-static CURLSTScode hstsreadfail(CURL *easy, struct curl_hstsentry *e,
+static CURLSTScode hstsreadfail(CURL *curl, struct curl_hstsentry *e,
                                 void *userp)
 {
-  (void)easy;
+  (void)curl;
   (void)e;
   (void)userp;
   return CURLSTS_FAIL;
 }
 
 /* check that we get the hosts back in the save */
-static CURLSTScode hstswrite(CURL *easy, struct curl_hstsentry *e,
+static CURLSTScode hstswrite(CURL *curl, struct curl_hstsentry *e,
                              struct curl_index *i, void *userp)
 {
-  (void)easy;
+  (void)curl;
   (void)userp;
   curl_mprintf("[%zu/%zu] %s %s\n", i->index, i->total, e->name, e->expire);
   return CURLSTS_OK;
@@ -98,7 +98,7 @@ static CURLSTScode hstswrite(CURL *easy, struct curl_hstsentry *e,
 static CURLcode test_lib1915(const char *URL)
 {
   CURLcode res = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   struct state st = {0};
 
   global_init(CURL_GLOBAL_ALL);
@@ -106,43 +106,43 @@ static CURLcode test_lib1915(const char *URL)
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
 
-  easy_init(hnd);
-  easy_setopt(hnd, CURLOPT_URL, URL);
-  easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 1L);
-  easy_setopt(hnd, CURLOPT_HSTSREADFUNCTION, hstsread);
-  easy_setopt(hnd, CURLOPT_HSTSREADDATA, &st);
-  easy_setopt(hnd, CURLOPT_HSTSWRITEFUNCTION, hstswrite);
-  easy_setopt(hnd, CURLOPT_HSTSWRITEDATA, &st);
-  easy_setopt(hnd, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE);
-  easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-  res = curl_easy_perform(hnd);
-  curl_easy_cleanup(hnd);
-  hnd = NULL;
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 1L);
+  easy_setopt(curl, CURLOPT_HSTSREADFUNCTION, hstsread);
+  easy_setopt(curl, CURLOPT_HSTSREADDATA, &st);
+  easy_setopt(curl, CURLOPT_HSTSWRITEFUNCTION, hstswrite);
+  easy_setopt(curl, CURLOPT_HSTSWRITEDATA, &st);
+  easy_setopt(curl, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  res = curl_easy_perform(curl);
+  curl_easy_cleanup(curl);
+  curl = NULL;
   if(res == CURLE_OPERATION_TIMEDOUT) /* we expect that on Windows */
     res = CURLE_COULDNT_CONNECT;
   curl_mprintf("First request returned %d\n", res);
   res = CURLE_OK;
 
-  easy_init(hnd);
-  easy_setopt(hnd, CURLOPT_URL, URL);
-  easy_setopt(hnd, CURLOPT_CONNECTTIMEOUT, 1L);
-  easy_setopt(hnd, CURLOPT_HSTSREADFUNCTION, hstsreadfail);
-  easy_setopt(hnd, CURLOPT_HSTSREADDATA, &st);
-  easy_setopt(hnd, CURLOPT_HSTSWRITEFUNCTION, hstswrite);
-  easy_setopt(hnd, CURLOPT_HSTSWRITEDATA, &st);
-  easy_setopt(hnd, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE);
-  easy_setopt(hnd, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(hnd, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(hnd, CURLOPT_VERBOSE, 1L);
-  res = curl_easy_perform(hnd);
-  curl_easy_cleanup(hnd);
-  hnd = NULL;
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 1L);
+  easy_setopt(curl, CURLOPT_HSTSREADFUNCTION, hstsreadfail);
+  easy_setopt(curl, CURLOPT_HSTSREADDATA, &st);
+  easy_setopt(curl, CURLOPT_HSTSWRITEFUNCTION, hstswrite);
+  easy_setopt(curl, CURLOPT_HSTSWRITEDATA, &st);
+  easy_setopt(curl, CURLOPT_HSTS_CTRL, CURLHSTS_ENABLE);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  res = curl_easy_perform(curl);
+  curl_easy_cleanup(curl);
+  curl = NULL;
   curl_mprintf("Second request returned %d\n", res);
 
 test_cleanup:
-  curl_easy_cleanup(hnd);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib1939.c

@@ -28,29 +28,29 @@
 static CURLcode test_lib1939(const char *URL)
 {
   CURLM *multi;
-  CURL *easy;
+  CURL *curl;
   int running_handles;
 
   curl_global_init(CURL_GLOBAL_DEFAULT);
 
   multi = curl_multi_init();
   if(multi) {
-    easy = curl_easy_init();
-    if(easy) {
+    curl = curl_easy_init();
+    if(curl) {
       CURLcode c;
       CURLMcode m;
 
       /* Crash only happens when using HTTPS */
-      c = curl_easy_setopt(easy, CURLOPT_URL, URL);
+      c = curl_easy_setopt(curl, CURLOPT_URL, URL);
       if(!c)
         /* Any old HTTP tunneling proxy will do here */
-        c = curl_easy_setopt(easy, CURLOPT_PROXY, libtest_arg2);
+        c = curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
 
       if(!c) {
 
         /* We're going to drive the transfer using multi interface here,
            because we want to stop during the middle. */
-        m = curl_multi_add_handle(multi, easy);
+        m = curl_multi_add_handle(multi, curl);
 
         if(!m)
           /* Run the multi handle once, just enough to start establishing an
@@ -62,7 +62,7 @@ static CURLcode test_lib1939(const char *URL)
       }
       /* Close the easy handle *before* the multi handle. Doing it the other
          way around avoids the issue. */
-      curl_easy_cleanup(easy);
+      curl_easy_cleanup(curl);
     }
     curl_multi_cleanup(multi); /* double-free happens here */
   }

tests/libtest/lib1940.c

@@ -33,7 +33,7 @@ static size_t t1940_write_cb(char *data, size_t n, size_t l, void *userp)
   return n*l;
 }
 
-static void t1940_showem(CURL *easy, int header_request, unsigned int type)
+static void t1940_showem(CURL *curl, int header_request, unsigned int type)
 {
   static const char *testdata[] = {
     "daTE",
@@ -52,7 +52,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type)
   int i;
   struct curl_header *header;
   for(i = 0; testdata[i]; i++) {
-    if(CURLHE_OK == curl_easy_header(easy, testdata[i], 0,
+    if(CURLHE_OK == curl_easy_header(curl, testdata[i], 0,
                                      type, header_request, &header)) {
       if(header->amount > 1) {
         /* more than one, iterate over them */
@@ -64,7 +64,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type)
 
           if(++index == amount)
             break;
-          if(CURLHE_OK != curl_easy_header(easy, testdata[i], index,
+          if(CURLHE_OK != curl_easy_header(curl, testdata[i], index,
                                            type, header_request, &header))
             break;
         } while(1);
@@ -79,7 +79,7 @@ static void t1940_showem(CURL *easy, int header_request, unsigned int type)
 
 static CURLcode test_lib1940(const char *URL)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
 
   int header_request;
@@ -91,32 +91,32 @@ static CURLcode test_lib1940(const char *URL)
   }
 
   global_init(CURL_GLOBAL_DEFAULT);
-  easy_init(easy);
-  easy_setopt(easy, CURLOPT_URL, URL);
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
-  easy_setopt(easy, CURLOPT_FOLLOWLOCATION, 1L);
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   /* ignores any content */
-  easy_setopt(easy, CURLOPT_WRITEFUNCTION, t1940_write_cb);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1940_write_cb);
 
   /* if there's a proxy set, use it */
   if(libtest_arg2 && *libtest_arg2) {
-    easy_setopt(easy, CURLOPT_PROXY, libtest_arg2);
-    easy_setopt(easy, CURLOPT_HTTPPROXYTUNNEL, 1L);
+    easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
+    easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L);
   }
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  t1940_showem(easy, header_request, CURLH_HEADER);
+  t1940_showem(curl, header_request, CURLH_HEADER);
   if(libtest_arg2 && *libtest_arg2) {
     /* now show connect headers only */
-    t1940_showem(easy, header_request, CURLH_CONNECT);
+    t1940_showem(curl, header_request, CURLH_CONNECT);
   }
-  t1940_showem(easy, header_request, CURLH_1XX);
-  t1940_showem(easy, header_request, CURLH_TRAILER);
+  t1940_showem(curl, header_request, CURLH_1XX);
+  t1940_showem(curl, header_request, CURLH_TRAILER);
 
 test_cleanup:
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib1945.c

@@ -25,13 +25,13 @@
 
 #include "memdebug.h"
 
-static void t1945_showem(CURL *easy, unsigned int type)
+static void t1945_showem(CURL *curl, unsigned int type)
 {
   struct curl_header *header = NULL;
   struct curl_header *prev = NULL;
 
   /* !checksrc! disable EQUALSNULL 1 */
-  while((header = curl_easy_nextheader(easy, type, 0, prev)) != NULL) {
+  while((header = curl_easy_nextheader(curl, type, 0, prev)) != NULL) {
     curl_mprintf(" %s == %s (%zu/%zu)\n", header->name, header->value,
                  header->index, header->amount);
     prev = header;
@@ -48,31 +48,31 @@ static size_t t1945_write_cb(char *data, size_t n, size_t l, void *userp)
 
 static CURLcode test_lib1945(const char *URL)
 {
-  CURL *easy;
+  CURL *curl;
   CURLcode res = CURLE_OK;
 
   global_init(CURL_GLOBAL_DEFAULT);
 
-  easy_init(easy);
-  curl_easy_setopt(easy, CURLOPT_URL, URL);
-  curl_easy_setopt(easy, CURLOPT_VERBOSE, 1L);
-  curl_easy_setopt(easy, CURLOPT_FOLLOWLOCATION, 1L);
+  easy_init(curl);
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   /* ignores any content */
-  curl_easy_setopt(easy, CURLOPT_WRITEFUNCTION, t1945_write_cb);
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, t1945_write_cb);
 
   /* if there's a proxy set, use it */
   if(libtest_arg2 && *libtest_arg2) {
-    curl_easy_setopt(easy, CURLOPT_PROXY, libtest_arg2);
-    curl_easy_setopt(easy, CURLOPT_HTTPPROXYTUNNEL, 1L);
+    curl_easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
+    curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L);
   }
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res) {
     curl_mprintf("badness: %d\n", res);
   }
-  t1945_showem(easy, CURLH_CONNECT|CURLH_HEADER|CURLH_TRAILER|CURLH_1XX);
+  t1945_showem(curl, CURLH_CONNECT|CURLH_HEADER|CURLH_TRAILER|CURLH_1XX);
 
 test_cleanup:
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib2032.c

@@ -28,13 +28,13 @@
 #define MAX_EASY_HANDLES 3
 
 static int ntlm_counter[MAX_EASY_HANDLES];
-static CURL *ntlm_easy[MAX_EASY_HANDLES];
+static CURL *ntlm_curls[MAX_EASY_HANDLES];
 static curl_socket_t ntlm_sockets[MAX_EASY_HANDLES];
 static CURLcode ntlmcb_res = CURLE_OK;
 
 static size_t callback(char *ptr, size_t size, size_t nmemb, void *data)
 {
-  ssize_t idx = ((CURL **) data) - ntlm_easy;
+  ssize_t idx = ((CURL **) data) - ntlm_curls;
   curl_socket_t sock;
   long longdata;
   CURLcode code;
@@ -44,7 +44,7 @@ static size_t callback(char *ptr, size_t size, size_t nmemb, void *data)
   ntlm_counter[idx] += (int)(size * nmemb);
 
   /* Get socket being used for this easy handle, otherwise CURL_SOCKET_BAD */
-  code = curl_easy_getinfo(ntlm_easy[idx], CURLINFO_LASTSOCKET, &longdata);
+  code = curl_easy_getinfo(ntlm_curls[idx], CURLINFO_LASTSOCKET, &longdata);
 
   if(CURLE_OK != code) {
     curl_mfprintf(stderr, "%s:%d curl_easy_getinfo() failed, "
@@ -102,7 +102,7 @@ static CURLcode test_lib2032(const char *URL)  /* libntlmconnect */
   }
 
   for(i = 0; i < MAX_EASY_HANDLES; ++i) {
-    ntlm_easy[i] = NULL;
+    ntlm_curls[i] = NULL;
     ntlm_sockets[i] = CURL_SOCKET_BAD;
   }
 
@@ -125,28 +125,28 @@ static CURLcode test_lib2032(const char *URL)  /* libntlmconnect */
 
     /* Start a new handle if we aren't at the max */
     if(state == ReadyForNewHandle) {
-      easy_init(ntlm_easy[num_handles]);
+      easy_init(ntlm_curls[num_handles]);
 
       if(num_handles % 3 == 2) {
         curl_msnprintf(full_url, urllen, "%s0200", URL);
-        easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
+        easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
       }
       else {
         curl_msnprintf(full_url, urllen, "%s0100", URL);
-        easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
+        easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
       }
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_FRESH_CONNECT, 1L);
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_URL, full_url);
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_VERBOSE, 1L);
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_HTTPGET, 1L);
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_USERPWD,
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_FRESH_CONNECT, 1L);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_URL, full_url);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_VERBOSE, 1L);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_HTTPGET, 1L);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_USERPWD,
                   "testuser:testpass");
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_WRITEFUNCTION, callback);
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_WRITEDATA,
-                  (void *)(ntlm_easy + num_handles));
-      easy_setopt(ntlm_easy[num_handles], CURLOPT_HEADER, 1L);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_WRITEFUNCTION, callback);
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_WRITEDATA,
+                  (void *)(ntlm_curls + num_handles));
+      easy_setopt(ntlm_curls[num_handles], CURLOPT_HEADER, 1L);
 
-      multi_add_handle(multi, ntlm_easy[num_handles]);
+      multi_add_handle(multi, ntlm_curls[num_handles]);
       num_handles += 1;
       state = NeedSocketForNewHandle;
       res = ntlmcb_res;
@@ -223,8 +223,8 @@ test_cleanup:
 
   for(i = 0; i < MAX_EASY_HANDLES; i++) {
     curl_mprintf("Data connection %d: %d\n", i, ntlm_counter[i]);
-    curl_multi_remove_handle(multi, ntlm_easy[i]);
-    curl_easy_cleanup(ntlm_easy[i]);
+    curl_multi_remove_handle(multi, ntlm_curls[i]);
+    curl_easy_cleanup(ntlm_curls[i]);
   }
 
   curl_multi_cleanup(multi);

tests/libtest/lib2301.c

@@ -42,7 +42,7 @@ static void t2301_websocket(CURL *curl)
 
 static size_t t2301_write_cb(char *b, size_t size, size_t nitems, void *p)
 {
-  CURL *easy = p;
+  CURL *curl = p;
   unsigned char *buffer = (unsigned char *)b;
   size_t i;
   size_t sent;
@@ -59,7 +59,7 @@ static size_t t2301_write_cb(char *b, size_t size, size_t nitems, void *p)
   if(buffer[0] == 0x89) {
     CURLcode result;
     curl_mfprintf(stderr, "send back a simple PONG\n");
-    result = curl_ws_send(easy, pong, 2, &sent, 0, 0);
+    result = curl_ws_send(curl, pong, 2, &sent, 0, 0);
     if(result)
       nitems = 0;
   }

tests/libtest/lib2302.c

@@ -26,7 +26,7 @@
 #ifndef CURL_DISABLE_WEBSOCKETS
 
 struct ws_data {
-  CURL *easy;
+  CURL *curl;
   char *buf;
   size_t blen;
   size_t nwrites;
@@ -83,7 +83,7 @@ static size_t t2302_write_cb(char *buffer, size_t size, size_t nitems, void *p)
   const struct curl_ws_frame *meta;
   (void)size;
 
-  meta = curl_ws_meta(ws_data->easy);
+  meta = curl_ws_meta(ws_data->curl);
   incoming = add_data(ws_data, buffer, incoming, meta);
 
   if(nitems != incoming)
@@ -106,7 +106,7 @@ static CURLcode test_lib2302(const char *URL)
   if(ws_data.buf) {
     curl = curl_easy_init();
     if(curl) {
-      ws_data.easy = curl;
+      ws_data.curl = curl;
 
       curl_easy_setopt(curl, CURLOPT_URL, URL);
       /* use the callback style */

tests/libtest/lib2306.c

@@ -26,24 +26,24 @@
 static CURLcode test_lib2306(const char *URL)
 {
   /* first a fine GET response, then a bad one */
-  CURL *cl;
+  CURL *curl;
   CURLcode res = CURLE_OK;
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(cl);
-  easy_setopt(cl, CURLOPT_URL, URL);
-  easy_setopt(cl, CURLOPT_VERBOSE, 1L);
-  res = curl_easy_perform(cl);
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
   /* reuse handle, do a second transfer */
-  easy_setopt(cl, CURLOPT_URL, libtest_arg2);
-  res = curl_easy_perform(cl);
+  easy_setopt(curl, CURLOPT_URL, libtest_arg2);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
-  curl_easy_cleanup(cl);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib2402.c

@@ -30,7 +30,7 @@ static CURLcode test_lib2402(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl[NUM_HANDLES] = {0};
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   size_t i;
   char target_url[256];
   char dnsentry[256];
@@ -53,9 +53,9 @@ static CURLcode test_lib2402(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L);
+  multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L);
 
   /* get each easy handle */
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
@@ -86,7 +86,7 @@ static CURLcode test_lib2402(const char *URL)
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
     /* add handle to multi */
-    multi_add_handle(m, curl[i]);
+    multi_add_handle(multi, curl[i]);
 
     for(;;) {
       struct timeval interval;
@@ -96,7 +96,7 @@ static CURLcode test_lib2402(const char *URL)
       interval.tv_sec = 1;
       interval.tv_usec = 0;
 
-      multi_perform(m, &running);
+      multi_perform(multi, &running);
 
       abort_on_test_timeout();
 
@@ -107,7 +107,7 @@ static CURLcode test_lib2402(const char *URL)
       FD_ZERO(&wr);
       FD_ZERO(&exc);
 
-      multi_fdset(m, &rd, &wr, &exc, &maxfd);
+      multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
       /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -123,13 +123,13 @@ test_cleanup:
   /* proper cleanup sequence - type PB */
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
-    curl_multi_remove_handle(m, curl[i]);
+    curl_multi_remove_handle(multi, curl[i]);
     curl_easy_cleanup(curl[i]);
   }
 
   curl_slist_free_all(slist);
 
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib2404.c

@@ -30,7 +30,7 @@ static CURLcode test_lib2404(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl[NUM_HANDLES] = {0};
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   size_t i;
   char target_url[256];
   char dnsentry[256];
@@ -53,9 +53,9 @@ static CURLcode test_lib2404(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L);
+  multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L);
 
   /* get each easy handle */
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
@@ -88,7 +88,7 @@ static CURLcode test_lib2404(const char *URL)
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
     /* add handle to multi */
-    multi_add_handle(m, curl[i]);
+    multi_add_handle(multi, curl[i]);
 
     for(;;) {
       struct timeval interval;
@@ -98,7 +98,7 @@ static CURLcode test_lib2404(const char *URL)
       interval.tv_sec = 1;
       interval.tv_usec = 0;
 
-      multi_perform(m, &running);
+      multi_perform(multi, &running);
 
       abort_on_test_timeout();
 
@@ -109,7 +109,7 @@ static CURLcode test_lib2404(const char *URL)
       FD_ZERO(&wr);
       FD_ZERO(&exc);
 
-      multi_fdset(m, &rd, &wr, &exc, &maxfd);
+      multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
       /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -125,13 +125,13 @@ test_cleanup:
   /* proper cleanup sequence - type PB */
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
-    curl_multi_remove_handle(m, curl[i]);
+    curl_multi_remove_handle(multi, curl[i]);
     curl_easy_cleanup(curl[i]);
   }
 
   curl_slist_free_all(slist);
 
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib2405.c

@@ -74,43 +74,43 @@ static size_t emptyWriteFunc(void *ptr, size_t size, size_t nmemb,
   return size * nmemb;
 }
 
-static CURLcode set_easy(const char *URL, CURL *easy, long option)
+static CURLcode set_easy(const char *URL, CURL *curl, long option)
 {
   CURLcode res = CURLE_OK;
 
   /* First set the URL that is about to receive our POST. */
-  easy_setopt(easy, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
   /* get verbose debug output please */
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   switch(option) {
   case TEST_USE_HTTP1:
     /* go http1 */
-    easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
+    easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_1);
     break;
 
   case TEST_USE_HTTP2:
     /* go http2 */
-    easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+    easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
     break;
 
   case TEST_USE_HTTP2_MPLEX:
     /* go http2 with multiplexing */
-    easy_setopt(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
-    easy_setopt(easy, CURLOPT_PIPEWAIT, 1L);
+    easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
+    easy_setopt(curl, CURLOPT_PIPEWAIT, 1L);
     break;
   }
 
   /* no peer verify */
-  easy_setopt(easy, CURLOPT_SSL_VERIFYPEER, 0L);
-  easy_setopt(easy, CURLOPT_SSL_VERIFYHOST, 0L);
+  easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+  easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
 
   /* include headers */
-  easy_setopt(easy, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
 
   /* empty write function */
-  easy_setopt(easy, CURLOPT_WRITEFUNCTION, emptyWriteFunc);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, emptyWriteFunc);
 
 test_cleanup:
   return res;
@@ -123,8 +123,8 @@ static CURLcode test_run(const char *URL, long option,
   CURLM *multi = NULL;
   CURLM *multi1 = NULL;
 
-  CURL *easy1 = NULL;
-  CURL *easy2 = NULL;
+  CURL *curl1 = NULL;
+  CURL *curl2 = NULL;
 
   unsigned int max_count = 0;
 
@@ -139,13 +139,13 @@ static CURLcode test_run(const char *URL, long option,
   struct curl_waitfd ufds1[10];
   int numfds;
 
-  easy_init(easy1);
-  easy_init(easy2);
+  easy_init(curl1);
+  easy_init(curl2);
 
-  if(set_easy(URL, easy1, option) != CURLE_OK)
+  if(set_easy(URL, curl1, option) != CURLE_OK)
     goto test_cleanup;
 
-  if(set_easy(URL, easy2, option) != CURLE_OK)
+  if(set_easy(URL, curl2, option) != CURLE_OK)
     goto test_cleanup;
 
   multi_init(multi);
@@ -154,8 +154,8 @@ static CURLcode test_run(const char *URL, long option,
   if(option == TEST_USE_HTTP2_MPLEX)
     multi_setopt(multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
 
-  multi_add_handle(multi, easy1);
-  multi_add_handle(multi, easy2);
+  multi_add_handle(multi, curl1);
+  multi_add_handle(multi, curl2);
 
   while(!mc) {
     /* get the count of file descriptors from the transfers */
@@ -293,12 +293,12 @@ static CURLcode test_run(const char *URL, long option,
     }
   }
 
-  curl_multi_remove_handle(multi, easy1);
-  curl_multi_remove_handle(multi, easy2);
+  curl_multi_remove_handle(multi, curl1);
+  curl_multi_remove_handle(multi, curl2);
 
 test_cleanup:
-  curl_easy_cleanup(easy1);
-  curl_easy_cleanup(easy2);
+  curl_easy_cleanup(curl1);
+  curl_easy_cleanup(curl2);
 
   curl_multi_cleanup(multi);
   curl_multi_cleanup(multi1);
@@ -313,7 +313,7 @@ static CURLcode empty_multi_test(void)
 {
   CURLMcode mc = CURLM_OK;
   CURLM *multi = NULL;
-  CURL *easy = NULL;
+  CURL *curl = NULL;
 
   struct curl_waitfd ufds[10];
 
@@ -338,12 +338,12 @@ static CURLcode empty_multi_test(void)
   }
 
   /* calling curl_multi_waitfds() on multi handle with added easy handle. */
-  easy_init(easy);
+  easy_init(curl);
 
-  if(set_easy("http://example.com", easy, TEST_USE_HTTP1) != CURLE_OK)
+  if(set_easy("http://example.com", curl, TEST_USE_HTTP1) != CURLE_OK)
     goto test_cleanup;
 
-  multi_add_handle(multi, easy);
+  multi_add_handle(multi, curl);
 
   mc = curl_multi_waitfds(multi, ufds, 10, &fd_count);
 
@@ -359,10 +359,10 @@ static CURLcode empty_multi_test(void)
     goto test_cleanup;
   }
 
-  curl_multi_remove_handle(multi, easy);
+  curl_multi_remove_handle(multi, curl);
 
 test_cleanup:
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_multi_cleanup(multi);
   return res;
 }

tests/libtest/lib2502.c

@@ -31,7 +31,7 @@ static CURLcode test_lib2502(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl[NUM_HANDLES] = {0};
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   size_t i;
   char target_url[256];
   char dnsentry[256];
@@ -54,9 +54,9 @@ static CURLcode test_lib2502(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_MAXCONNECTS, 1L);
+  multi_setopt(multi, CURLMOPT_MAXCONNECTS, 1L);
 
   /* get each easy handle */
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
@@ -90,7 +90,7 @@ static CURLcode test_lib2502(const char *URL)
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
     /* add handle to multi */
-    multi_add_handle(m, curl[i]);
+    multi_add_handle(multi, curl[i]);
 
     for(;;) {
       struct timeval interval;
@@ -100,7 +100,7 @@ static CURLcode test_lib2502(const char *URL)
       interval.tv_sec = 1;
       interval.tv_usec = 0;
 
-      multi_perform(m, &running);
+      multi_perform(multi, &running);
 
       abort_on_test_timeout();
 
@@ -111,7 +111,7 @@ static CURLcode test_lib2502(const char *URL)
       FD_ZERO(&wr);
       FD_ZERO(&exc);
 
-      multi_fdset(m, &rd, &wr, &exc, &maxfd);
+      multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
       /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -127,13 +127,13 @@ test_cleanup:
   /* proper cleanup sequence - type PB */
 
   for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
-    curl_multi_remove_handle(m, curl[i]);
+    curl_multi_remove_handle(multi, curl[i]);
     curl_easy_cleanup(curl[i]);
   }
 
   curl_slist_free_all(slist);
 
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib3027.c

@@ -28,26 +28,26 @@
 static CURLcode test_lib3027(const char *URL)
 {
   CURLcode ret = CURLE_OK;
-  CURL *hnd;
+  CURL *curl;
   start_test_timing();
 
   curl_global_init(CURL_GLOBAL_ALL);
 
-  hnd = curl_easy_init();
-  if(hnd) {
-    curl_easy_setopt(hnd, CURLOPT_URL, URL);
-    curl_easy_setopt(hnd, CURLOPT_FILETIME, 1L);
-    ret = curl_easy_perform(hnd);
+  curl = curl_easy_init();
+  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) {
       long filetime;
-      ret = curl_easy_getinfo(hnd, CURLINFO_FILETIME, &filetime);
+      ret = curl_easy_getinfo(curl, CURLINFO_FILETIME, &filetime);
       /* MTDM fails with 550, so filetime should be -1 */
       if((CURLE_OK == ret) && (filetime != -1)) {
         /* we just need to return something which is not CURLE_OK */
         ret = CURLE_UNSUPPORTED_PROTOCOL;
       }
     }
-    curl_easy_cleanup(hnd);
+    curl_easy_cleanup(curl);
   }
   curl_global_cleanup();
   return ret;

tests/libtest/lib3033.c

@@ -27,7 +27,7 @@
 
 #include "memdebug.h"
 
-static CURLcode t3033_req_test(CURLM *multi, CURL *easy,
+static CURLcode t3033_req_test(CURLM *multi, CURL *curl,
                                const char *URL, int index)
 {
   CURLMsg *msg = NULL;
@@ -43,13 +43,13 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy,
     curl_mprintf("[%d] no network change\n", index);
   }
 
-  curl_easy_reset(easy);
-  curl_easy_setopt(easy, CURLOPT_URL, URL);
-  easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  curl_easy_reset(curl);
+  curl_easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  curl_multi_add_handle(multi, easy);
+  curl_multi_add_handle(multi, curl);
 
   do {
     CURLMcode mres;
@@ -76,7 +76,7 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy,
         goto test_cleanup;
       }
 
-      curl_easy_getinfo(easy, CURLINFO_NUM_CONNECTS, &num_connects);
+      curl_easy_getinfo(curl, CURLINFO_NUM_CONNECTS, &num_connects);
       if(index == 1 && num_connects == 0) {
         curl_mprintf("[1] should not reuse connection in pool\n");
         res = TEST_ERR_MAJOR_BAD;
@@ -92,7 +92,7 @@ static CURLcode t3033_req_test(CURLM *multi, CURL *easy,
 
 test_cleanup:
 
-  curl_multi_remove_handle(multi, easy);
+  curl_multi_remove_handle(multi, curl);
 
   return res;
 }

tests/libtest/lib3105.c

@@ -27,7 +27,7 @@
 
 static CURLcode test_lib3105(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   CURLcode i = CURLE_OK;
   CURLcode res = CURLE_OK;
@@ -37,14 +37,14 @@ static CURLcode test_lib3105(const char *URL)
 
   multi_init(multi);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
-  multi_add_handle(multi, curls);
+  multi_add_handle(multi, curl);
 
-  mc = curl_multi_remove_handle(multi, curls);
-  mc += curl_multi_remove_handle(multi, curls);
+  mc = curl_multi_remove_handle(multi, curl);
+  mc += curl_multi_remove_handle(multi, curl);
 
   if(mc) {
     curl_mfprintf(stderr, "%d was unexpected\n", mc);
@@ -53,7 +53,7 @@ static CURLcode test_lib3105(const char *URL)
 
 test_cleanup:
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   if(res)

tests/libtest/lib3207.c

@@ -115,19 +115,19 @@ test_cleanup:
 
 #if defined(USE_THREADS_POSIX) || defined(USE_THREADS_WIN32)
 
-static void t3207_test_lock(CURL *handle, curl_lock_data data,
+static void t3207_test_lock(CURL *curl, curl_lock_data data,
                             curl_lock_access laccess, void *useptr)
 {
   curl_mutex_t *mutexes = (curl_mutex_t*) useptr;
-  (void)handle;
+  (void)curl;
   (void)laccess;
   Curl_mutex_acquire(&mutexes[data]);
 }
 
-static void t3207_test_unlock(CURL *handle, curl_lock_data data, void *useptr)
+static void t3207_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
 {
   curl_mutex_t *mutexes = (curl_mutex_t*) useptr;
-  (void)handle;
+  (void)curl;
   Curl_mutex_release(&mutexes[data]);
 }
 

tests/libtest/lib502.c

@@ -31,8 +31,8 @@
 
 static CURLcode test_lib502(const char *URL)
 {
-  CURL *c = NULL;
-  CURLM *m = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int running;
 
@@ -40,13 +40,13 @@ static CURLcode test_lib502(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(c);
+  easy_init(curl);
 
-  easy_setopt(c, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, c);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval timeout;
@@ -56,7 +56,7 @@ static CURLcode test_lib502(const char *URL)
     timeout.tv_sec = 0;
     timeout.tv_usec = 100000L; /* 100 ms */
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -67,7 +67,7 @@ static CURLcode test_lib502(const char *URL)
     FD_ZERO(&fdwrite);
     FD_ZERO(&fdexcep);
 
-    multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -80,9 +80,9 @@ test_cleanup:
 
   /* proper cleanup sequence - type PA */
 
-  curl_multi_remove_handle(m, c);
-  curl_multi_cleanup(m);
-  curl_easy_cleanup(c);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib503.c

@@ -35,8 +35,8 @@
 
 static CURLcode test_lib503(const char *URL)
 {
-  CURL *c = NULL;
-  CURLM *m = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int running;
 
@@ -44,20 +44,20 @@ static CURLcode test_lib503(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(c);
+  easy_init(curl);
 
-  easy_setopt(c, CURLOPT_PROXY, libtest_arg2); /* set in first.c */
-  easy_setopt(c, CURLOPT_URL, URL);
-  easy_setopt(c, CURLOPT_USERPWD, "test:ing");
-  easy_setopt(c, CURLOPT_PROXYUSERNAME, "test%20");
-  easy_setopt(c, CURLOPT_PROXYPASSWORD, "ing%41");
-  easy_setopt(c, CURLOPT_HTTPPROXYTUNNEL, 1L);
-  easy_setopt(c, CURLOPT_HEADER, 1L);
-  easy_setopt(c, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_PROXY, libtest_arg2); /* set in first.c */
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_USERPWD, "test:ing");
+  easy_setopt(curl, CURLOPT_PROXYUSERNAME, "test%20");
+  easy_setopt(curl, CURLOPT_PROXYPASSWORD, "ing%41");
+  easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, 1L);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, c);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval interval;
@@ -67,7 +67,7 @@ static CURLcode test_lib503(const char *URL)
     interval.tv_sec = 1;
     interval.tv_usec = 0;
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -78,7 +78,7 @@ static CURLcode test_lib503(const char *URL)
     FD_ZERO(&wr);
     FD_ZERO(&exc);
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -91,9 +91,9 @@ test_cleanup:
 
   /* proper cleanup sequence - type PA */
 
-  curl_multi_remove_handle(m, c);
-  curl_multi_cleanup(m);
-  curl_easy_cleanup(c);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib504.c

@@ -34,9 +34,9 @@
  */
 static CURLcode test_lib504(const char *URL)
 {
-  CURL *c = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   fd_set rd, wr, exc;
   int running;
 
@@ -44,18 +44,18 @@ static CURLcode test_lib504(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(c);
+  easy_init(curl);
 
   /* The point here is that there must not be anything running on the given
      proxy port */
   if(libtest_arg2)
-    easy_setopt(c, CURLOPT_PROXY, libtest_arg2);
-  easy_setopt(c, CURLOPT_URL, URL);
-  easy_setopt(c, CURLOPT_VERBOSE, 1L);
+    easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, c);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval interval;
@@ -66,12 +66,12 @@ static CURLcode test_lib504(const char *URL)
 
     curl_mfprintf(stderr, "curl_multi_perform()\n");
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     while(running) {
       CURLMcode mres;
       int num;
-      mres = curl_multi_wait(m, NULL, 0, TEST_HANG_TIMEOUT, &num);
+      mres = curl_multi_wait(multi, NULL, 0, TEST_HANG_TIMEOUT, &num);
       if(mres != CURLM_OK) {
         curl_mprintf("curl_multi_wait() returned %d\n", mres);
         res = TEST_ERR_MAJOR_BAD;
@@ -79,7 +79,7 @@ static CURLcode test_lib504(const char *URL)
       }
 
       abort_on_test_timeout();
-      multi_perform(m, &running);
+      multi_perform(multi, &running);
       abort_on_test_timeout();
     }
 
@@ -88,7 +88,7 @@ static CURLcode test_lib504(const char *URL)
     if(!running) {
       /* This is where this code is expected to reach */
       int numleft;
-      CURLMsg *msg = curl_multi_info_read(m, &numleft);
+      CURLMsg *msg = curl_multi_info_read(multi, &numleft);
       curl_mfprintf(stderr, "Expected: not running\n");
       if(msg && !numleft)
         res = TEST_ERR_SUCCESS; /* this is where we should be */
@@ -104,7 +104,7 @@ static CURLcode test_lib504(const char *URL)
 
     curl_mfprintf(stderr, "curl_multi_fdset()\n");
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -117,9 +117,9 @@ test_cleanup:
 
   /* proper cleanup sequence - type PA */
 
-  curl_multi_remove_handle(m, c);
-  curl_multi_cleanup(m);
-  curl_easy_cleanup(c);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib506.c

@@ -42,14 +42,14 @@ struct t506_userdata {
 static int locks[3];
 
 /* lock callback */
-static void t506_test_lock(CURL *handle, curl_lock_data data,
+static void t506_test_lock(CURL *curl, curl_lock_data data,
                            curl_lock_access laccess, void *useptr)
 {
   const char *what;
   struct t506_userdata *user = (struct t506_userdata *)useptr;
   int locknum;
 
-  (void)handle;
+  (void)curl;
   (void)laccess;
 
   switch(data) {
@@ -82,12 +82,12 @@ static void t506_test_lock(CURL *handle, curl_lock_data data,
 }
 
 /* unlock callback */
-static void t506_test_unlock(CURL *handle, curl_lock_data data, void *useptr)
+static void t506_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
 {
   const char *what;
   struct t506_userdata *user = (struct t506_userdata *)useptr;
   int locknum;
-  (void)handle;
+  (void)curl;
   switch(data) {
     case CURL_LOCK_DATA_SHARE:
       what = "share";

tests/libtest/lib507.c

@@ -27,7 +27,7 @@
 
 static CURLcode test_lib507(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   int still_running;
   CURLcode i = TEST_ERR_MAJOR_BAD;
@@ -40,12 +40,12 @@ static CURLcode test_lib507(const char *URL)
 
   multi_init(multi);
 
-  easy_init(curls);
+  easy_init(curl);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
 
-  multi_add_handle(multi, curls);
+  multi_add_handle(multi, curl);
 
   multi_perform(multi, &still_running);
 
@@ -88,7 +88,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UA */
 
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   if(res)

tests/libtest/lib525.c

@@ -33,7 +33,7 @@ static CURLcode test_lib525(const char *URL)
   FILE *hd_src = NULL;
   int hd;
   struct_stat file_info;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   int running;
 
   start_test_timing();
@@ -101,9 +101,9 @@ static CURLcode test_lib525(const char *URL)
      make sure that to pass in a type 'long' argument. */
   easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval interval;
@@ -113,7 +113,7 @@ static CURLcode test_lib525(const char *URL)
     interval.tv_sec = 1;
     interval.tv_usec = 0;
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -124,7 +124,7 @@ static CURLcode test_lib525(const char *URL)
     FD_ZERO(&wr);
     FD_ZERO(&exc);
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -137,16 +137,16 @@ test_cleanup:
 
   if(testnum == 529) {
     /* proper cleanup sequence - type PA */
-    curl_multi_remove_handle(m, curl);
-    curl_multi_cleanup(m);
+    curl_multi_remove_handle(multi, curl);
+    curl_multi_cleanup(multi);
     curl_easy_cleanup(curl);
     curl_global_cleanup();
   }
   else { /* testnum == 525 */
     /* proper cleanup sequence - type PB */
-    curl_multi_remove_handle(m, curl);
+    curl_multi_remove_handle(multi, curl);
     curl_easy_cleanup(curl);
-    curl_multi_cleanup(m);
+    curl_multi_cleanup(multi);
     curl_global_cleanup();
   }
 

tests/libtest/lib526.c

@@ -49,7 +49,7 @@ static CURLcode test_lib526(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl[NUM_HANDLES];
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   size_t current = 0;
   size_t i;
 
@@ -69,9 +69,9 @@ static CURLcode test_lib526(const char *URL)
     easy_setopt(curl[i], CURLOPT_VERBOSE, 1L);
   }
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, curl[current]);
+  multi_add_handle(multi, curl[current]);
 
   curl_mfprintf(stderr, "Start at URL 0\n");
 
@@ -83,7 +83,7 @@ static CURLcode test_lib526(const char *URL)
     interval.tv_sec = 1;
     interval.tv_usec = 0;
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -99,7 +99,7 @@ static CURLcode test_lib526(const char *URL)
         curl_mfprintf(stderr, "Advancing to URL %zu\n", current);
         if(testnum == 532) {
           /* first remove the only handle we use */
-          curl_multi_remove_handle(m, curl[0]);
+          curl_multi_remove_handle(multi, curl[0]);
 
           /* make us reuse the same handle all the time, and try resetting
              the handle first too */
@@ -109,10 +109,10 @@ static CURLcode test_lib526(const char *URL)
           easy_setopt(curl[0], CURLOPT_VERBOSE, 1L);
 
           /* re-add it */
-          multi_add_handle(m, curl[0]);
+          multi_add_handle(multi, curl[0]);
         }
         else {
-          multi_add_handle(m, curl[current]);
+          multi_add_handle(multi, curl[current]);
         }
       }
       else {
@@ -124,7 +124,7 @@ static CURLcode test_lib526(const char *URL)
     FD_ZERO(&wr);
     FD_ZERO(&exc);
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -139,10 +139,10 @@ test_cleanup:
     /* proper cleanup sequence - type PB */
 
     for(i = 0; i < CURL_ARRAYSIZE(curl); i++) {
-      curl_multi_remove_handle(m, curl[i]);
+      curl_multi_remove_handle(multi, curl[i]);
       curl_easy_cleanup(curl[i]);
     }
-    curl_multi_cleanup(m);
+    curl_multi_cleanup(multi);
     curl_global_cleanup();
   }
   else if(testnum == 527) {
@@ -155,7 +155,7 @@ test_cleanup:
       for(i = 0; i < CURL_ARRAYSIZE(curl); i++)
         curl_easy_cleanup(curl[i]);
 
-    curl_multi_cleanup(m);
+    curl_multi_cleanup(multi);
     curl_global_cleanup();
 
   }
@@ -164,7 +164,7 @@ test_cleanup:
 
     for(i = 0; i < CURL_ARRAYSIZE(curl); i++)
       curl_easy_cleanup(curl[i]);
-    curl_multi_cleanup(m);
+    curl_multi_cleanup(multi);
     curl_global_cleanup();
   }
 

tests/libtest/lib530.c

@@ -131,12 +131,12 @@ static int t530_addFd(struct t530_Sockets *sockets, curl_socket_t fd,
 /**
  * Callback invoked by curl to poll reading / writing of a socket.
  */
-static int t530_curlSocketCallback(CURL *easy, curl_socket_t s, int action,
+static int t530_curlSocketCallback(CURL *curl, curl_socket_t s, int action,
                                    void *userp, void *socketp)
 {
   struct t530_ReadWriteSockets *sockets = userp;
 
-  (void)easy;
+  (void)curl;
   (void)socketp;
 
   t530_ctx.socket_calls++;
@@ -189,13 +189,13 @@ static int t530_curlTimerCallback(CURLM *multi, long timeout_ms, void *userp)
 /**
  * Check for curl completion.
  */
-static int t530_checkForCompletion(CURLM *curl, int *success)
+static int t530_checkForCompletion(CURLM *multi, int *success)
 {
   int result = 0;
   *success = 0;
   while(1) {
     int numMessages;
-    CURLMsg *message = curl_multi_info_read(curl, &numMessages);
+    CURLMsg *message = curl_multi_info_read(multi, &numMessages);
     if(!message)
       break;
     if(message->msg == CURLMSG_DONE) {
@@ -250,11 +250,12 @@ static void t530_updateFdSet(struct t530_Sockets *sockets, fd_set* fdset,
   }
 }
 
-static CURLMcode socket_action(CURLM *curl, curl_socket_t s, int evBitmask,
+static CURLMcode socket_action(CURLM *multi, curl_socket_t s, int evBitmask,
                                const char *info)
 {
   int numhandles = 0;
-  CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
+  CURLMcode result = curl_multi_socket_action(multi, s, evBitmask,
+                                              &numhandles);
   if(result != CURLM_OK) {
     curl_mfprintf(stderr, "%s Curl error on %s (%i) %s\n",
                   t530_tag(), info, result, curl_multi_strerror(result));
@@ -265,7 +266,7 @@ static CURLMcode socket_action(CURLM *curl, curl_socket_t s, int evBitmask,
 /**
  * Invoke curl when a file descriptor is set.
  */
-static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets,
+static CURLMcode t530_checkFdSet(CURLM *multi, struct t530_Sockets *sockets,
                                  fd_set *fdset, int evBitmask,
                                  const char *name)
 {
@@ -273,7 +274,7 @@ static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets,
   CURLMcode result = CURLM_OK;
   for(i = 0; i < sockets->count; ++i) {
     if(FD_ISSET(sockets->sockets[i], fdset)) {
-      result = socket_action(curl, sockets->sockets[i], evBitmask, name);
+      result = socket_action(multi, sockets->sockets[i], evBitmask, name);
       if(result)
         break;
     }
@@ -284,7 +285,8 @@ static CURLMcode t530_checkFdSet(CURLM *curl, struct t530_Sockets *sockets,
 static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at)
 {
   CURLcode res = CURLE_OK;
-  CURL *curl = NULL;  CURLM *m = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   struct t530_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}};
   int success = 0;
   struct curltime timeout = {0};
@@ -310,22 +312,22 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at)
   /* go verbose */
   easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t530_curlSocketCallback);
-  multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
+  multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t530_curlSocketCallback);
+  multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets);
 
-  multi_setopt(m, CURLMOPT_TIMERFUNCTION, t530_curlTimerCallback);
-  multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
+  multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t530_curlTimerCallback);
+  multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
-  if(socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+  if(socket_action(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
     res = TEST_ERR_MAJOR_BAD;
     goto test_cleanup;
   }
 
-  while(!t530_checkForCompletion(m, &success)) {
+  while(!t530_checkForCompletion(multi, &success)) {
     fd_set readSet, writeSet;
     curl_socket_t maxFd = 0;
     struct timeval tv = {0};
@@ -350,12 +352,12 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at)
     select_test((int)maxFd, &readSet, &writeSet, NULL, &tv);
 
     /* Check the sockets for reading / writing */
-    if(t530_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN,
+    if(t530_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN,
                        "read")) {
       res = TEST_ERR_MAJOR_BAD;
       goto test_cleanup;
     }
-    if(t530_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT,
+    if(t530_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT,
                        "write")) {
       res = TEST_ERR_MAJOR_BAD;
       goto test_cleanup;
@@ -364,7 +366,7 @@ static CURLcode testone(const char *URL, int timer_fail_at, int socket_fail_at)
     if(timeout.tv_sec != (time_t)-1 &&
        t530_getMicroSecondTimeout(&timeout) == 0) {
       /* Curl's timer has elapsed. */
-      if(socket_action(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+      if(socket_action(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
         res = TEST_ERR_BAD_TIMEOUT;
         goto test_cleanup;
       }
@@ -382,9 +384,9 @@ test_cleanup:
 
   /* proper cleanup sequence */
   t530_msg("cleanup");
-  curl_multi_remove_handle(m, curl);
+  curl_multi_remove_handle(multi, curl);
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   /* free local memory */

tests/libtest/lib533.c

@@ -32,7 +32,7 @@ static CURLcode test_lib533(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl = NULL;
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   int current = 0;
 
   start_test_timing();
@@ -45,9 +45,9 @@ static CURLcode test_lib533(const char *URL)
   easy_setopt(curl, CURLOPT_VERBOSE, 1L);
   easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
   curl_mfprintf(stderr, "Start at URL 0\n");
 
@@ -59,7 +59,7 @@ static CURLcode test_lib533(const char *URL)
     interval.tv_sec = 1;
     interval.tv_usec = 0;
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -67,7 +67,7 @@ static CURLcode test_lib533(const char *URL)
       if(!current++) {
         curl_mfprintf(stderr, "Advancing to URL 1\n");
         /* remove the handle we use */
-        curl_multi_remove_handle(m, curl);
+        curl_multi_remove_handle(multi, curl);
 
         /* make us reuse the same handle all the time, and try resetting
            the handle first too */
@@ -77,7 +77,7 @@ static CURLcode test_lib533(const char *URL)
         easy_setopt(curl, CURLOPT_FAILONERROR, 1L);
 
         /* re-add it */
-        multi_add_handle(m, curl);
+        multi_add_handle(multi, curl);
       }
       else
         break; /* done */
@@ -87,7 +87,7 @@ static CURLcode test_lib533(const char *URL)
     FD_ZERO(&wr);
     FD_ZERO(&exc);
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -101,7 +101,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UB */
 
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib540.c

@@ -34,48 +34,49 @@
 
 #include "memdebug.h"
 
-static CURL *testeh[2];
+static CURL *t540_curl[2];
 
-static CURLcode init(int num, CURLM *cm, const char *url, const char *userpwd,
-                     struct curl_slist *headers)
+static CURLcode init(int num, CURLM *multi, const char *url,
+                     const char *userpwd, struct curl_slist *headers)
 {
   CURLcode res = CURLE_OK;
 
   const char *proxy = libtest_arg2;
 
-  res_easy_init(testeh[num]);
+  res_easy_init(t540_curl[num]);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_URL, url);
+  res_easy_setopt(t540_curl[num], CURLOPT_URL, url);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_PROXY, proxy);
+  res_easy_setopt(t540_curl[num], CURLOPT_PROXY, proxy);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_PROXYUSERPWD, userpwd);
+  res_easy_setopt(t540_curl[num], CURLOPT_PROXYUSERPWD, userpwd);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+  res_easy_setopt(t540_curl[num], CURLOPT_PROXYAUTH, CURLAUTH_ANY);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_VERBOSE, 1L);
+  res_easy_setopt(t540_curl[num], CURLOPT_VERBOSE, 1L);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_HEADER, 1L);
+  res_easy_setopt(t540_curl[num], CURLOPT_HEADER, 1L);
   if(res)
     goto init_failed;
 
-  res_easy_setopt(testeh[num], CURLOPT_HTTPHEADER, headers); /* custom Host: */
+  /* custom Host: */
+  res_easy_setopt(t540_curl[num], CURLOPT_HTTPHEADER, headers);
   if(res)
     goto init_failed;
 
-  res_multi_add_handle(cm, testeh[num]);
+  res_multi_add_handle(multi, t540_curl[num]);
   if(res)
     goto init_failed;
 
@@ -83,14 +84,14 @@ static CURLcode init(int num, CURLM *cm, const char *url, const char *userpwd,
 
 init_failed:
 
-  curl_easy_cleanup(testeh[num]);
-  testeh[num] = NULL;
+  curl_easy_cleanup(t540_curl[num]);
+  t540_curl[num] = NULL;
 
   return res; /* failure */
 }
 
-static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
-                     struct curl_slist *headers)
+static CURLcode loop(int num, CURLM *multi, const char *url,
+                     const char *userpwd, struct curl_slist *headers)
 {
   CURLMsg *msg;
   long L;
@@ -99,7 +100,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
   struct timeval T;
   CURLcode res = CURLE_OK;
 
-  res = init(num, cm, url, userpwd, headers);
+  res = init(num, multi, url, userpwd, headers);
   if(res)
     return res;
 
@@ -107,7 +108,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
 
     int M = -99;
 
-    res_multi_perform(cm, &U);
+    res_multi_perform(multi, &U);
     if(res)
       return res;
 
@@ -120,13 +121,13 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
       FD_ZERO(&W);
       FD_ZERO(&E);
 
-      res_multi_fdset(cm, &R, &W, &E, &M);
+      res_multi_fdset(multi, &R, &W, &E, &M);
       if(res)
         return res;
 
       /* At this point, M is guaranteed to be greater or equal than -1. */
 
-      res_multi_timeout(cm, &L);
+      res_multi_timeout(multi, &L);
       if(res)
         return res;
 
@@ -153,19 +154,19 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
     }
 
     while(1) {
-      msg = curl_multi_info_read(cm, &Q);
+      msg = curl_multi_info_read(multi, &Q);
       if(!msg)
         break;
       if(msg->msg == CURLMSG_DONE) {
         size_t i;
-        CURL *e = msg->easy_handle;
+        CURL *curl = msg->easy_handle;
         curl_mfprintf(stderr, "R: %d - %s\n", msg->data.result,
                       curl_easy_strerror(msg->data.result));
-        curl_multi_remove_handle(cm, e);
-        curl_easy_cleanup(e);
-        for(i = 0; i < CURL_ARRAYSIZE(testeh); i++) {
-          if(testeh[i] == e) {
-            testeh[i] = NULL;
+        curl_multi_remove_handle(multi, curl);
+        curl_easy_cleanup(curl);
+        for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++) {
+          if(t540_curl[i] == curl) {
+            t540_curl[i] = NULL;
             break;
           }
         }
@@ -184,7 +185,7 @@ static CURLcode loop(int num, CURLM *cm, const char *url, const char *userpwd,
 
 static CURLcode test_lib540(const char *URL)
 {
-  CURLM *cm = NULL;
+  CURLM *multi = NULL;
   struct curl_slist *headers = NULL;
   char buffer[246]; /* naively fixed-size */
   CURLcode res = CURLE_OK;
@@ -193,8 +194,8 @@ static CURLcode test_lib540(const char *URL)
   const char *proxyuserpws = libtest_arg3;
   const char *host;
 
-  for(i = 0; i < CURL_ARRAYSIZE(testeh); i++)
-    testeh[i] = NULL;
+  for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++)
+    t540_curl[i] = NULL;
 
   start_test_timing();
 
@@ -217,31 +218,31 @@ static CURLcode test_lib540(const char *URL)
     return res;
   }
 
-  res_multi_init(cm);
+  res_multi_init(multi);
   if(res) {
     curl_global_cleanup();
     curl_slist_free_all(headers);
     return res;
   }
 
-  res = loop(0, cm, URL, proxyuserpws, headers);
+  res = loop(0, multi, URL, proxyuserpws, headers);
   if(res)
     goto test_cleanup;
 
   curl_mfprintf(stderr, "lib540: now we do the request again\n");
 
-  res = loop(1, cm, URL, proxyuserpws, headers);
+  res = loop(1, multi, URL, proxyuserpws, headers);
 
 test_cleanup:
 
   /* proper cleanup sequence - type PB */
 
-  for(i = 0; i < CURL_ARRAYSIZE(testeh); i++) {
-    curl_multi_remove_handle(cm, testeh[i]);
-    curl_easy_cleanup(testeh[i]);
+  for(i = 0; i < CURL_ARRAYSIZE(t540_curl); i++) {
+    curl_multi_remove_handle(multi, t540_curl[i]);
+    curl_easy_cleanup(t540_curl[i]);
   }
 
-  curl_multi_cleanup(cm);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   curl_slist_free_all(headers);

tests/libtest/lib543.c

@@ -34,37 +34,37 @@ static CURLcode test_lib543(const char *URL)
       0xe0, 0xd8, 0x7c,  0x20, 0xb7, 0xef, 0x53, 0x29, 0xfa,
       0x1d, 0x57, 0xe1};
 
-  CURL *easy;
+  CURL *curl;
   CURLcode res = CURLE_OK;
   (void)URL;
 
   global_init(CURL_GLOBAL_ALL);
-  easy = curl_easy_init();
-  if(!easy) {
+  curl = curl_easy_init();
+  if(!curl) {
     curl_mfprintf(stderr, "curl_easy_init() failed\n");
     res = TEST_ERR_MAJOR_BAD;
   }
   else {
     int asize = (int)sizeof(a);
-    char *s = curl_easy_escape(easy, (const char *)a, asize);
+    char *s = curl_easy_escape(curl, (const char *)a, asize);
 
     if(s) {
       curl_mprintf("%s\n", s);
       curl_free(s);
     }
 
-    s = curl_easy_escape(easy, "", 0);
+    s = curl_easy_escape(curl, "", 0);
     if(s) {
       curl_mprintf("IN: '' OUT: '%s'\n", s);
       curl_free(s);
     }
-    s = curl_easy_escape(easy, " 123", 3);
+    s = curl_easy_escape(curl, " 123", 3);
     if(s) {
       curl_mprintf("IN: ' 12' OUT: '%s'\n", s);
       curl_free(s);
     }
 
-    curl_easy_cleanup(easy);
+    curl_easy_cleanup(curl);
   }
   curl_global_cleanup();
 

tests/libtest/lib544.c

@@ -67,11 +67,11 @@ static CURLcode test_lib544(const char *URL)
   strcpy(teststring, "FAIL");
 
   {
-    CURL *handle2;
-    handle2 = curl_easy_duphandle(curl);
+    CURL *curl2;
+    curl2 = curl_easy_duphandle(curl);
     curl_easy_cleanup(curl);
 
-    curl = handle2;
+    curl = curl2;
   }
 
   /* Now, this is a POST request with binary 0 embedded in POST data. */

tests/libtest/lib547.c

@@ -53,10 +53,10 @@ static size_t t547_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp)
   return 0;
 }
 
-static curlioerr t547_ioctl_callback(CURL *handle, int cmd, void *clientp)
+static curlioerr t547_ioctl_callback(CURL *curl, int cmd, void *clientp)
 {
   int *counter = (int *)clientp;
-  (void)handle;
+  (void)curl;
   if(cmd == CURLIOCMD_RESTARTREAD) {
     curl_mfprintf(stderr, "REWIND!\n");
     *counter = 0; /* clear counter to make the read callback restart */

tests/libtest/lib552.c

@@ -54,7 +54,7 @@ static size_t t552_write_cb(char *ptr, size_t size, size_t nmemb, void *stream)
   return amount;
 }
 
-static curlioerr ioctl_callback(CURL *handle, int cmd, void *clientp)
+static curlioerr ioctl_callback(CURL *curl, int cmd, void *clientp)
 {
   (void)clientp;
   if(cmd == CURLIOCMD_RESTARTREAD) {
@@ -63,7 +63,7 @@ static curlioerr ioctl_callback(CURL *handle, int cmd, void *clientp)
     current_offset = 0;
     return CURLIOE_OK;
   }
-  (void)handle;
+  (void)curl;
   return CURLIOE_UNKNOWNCMD;
 }
 

tests/libtest/lib555.c

@@ -57,10 +57,10 @@ static size_t t555_read_cb(char *ptr, size_t size, size_t nmemb, void *clientp)
   return 0;
 }
 
-static curlioerr t555_ioctl_callback(CURL *handle, int cmd, void *clientp)
+static curlioerr t555_ioctl_callback(CURL *curl, int cmd, void *clientp)
 {
   int *counter = (int *)clientp;
-  (void)handle;
+  (void)curl;
   if(cmd == CURLIOCMD_RESTARTREAD) {
     curl_mfprintf(stderr, "REWIND!\n");
     *counter = 0; /* clear counter to make the read callback restart */
@@ -73,7 +73,7 @@ static CURLcode test_lib555(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl = NULL;
   int counter = 0;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   int running = 1;
 
   start_test_timing();
@@ -102,9 +102,9 @@ static CURLcode test_lib555(const char *URL)
   easy_setopt(curl, CURLOPT_PROXYAUTH,
               CURLAUTH_BASIC | CURLAUTH_DIGEST | CURLAUTH_NTLM);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
   while(running) {
     struct timeval timeout;
@@ -114,7 +114,7 @@ static CURLcode test_lib555(const char *URL)
     timeout.tv_sec = 0;
     timeout.tv_usec = 100000L; /* 100 ms */
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -125,7 +125,7 @@ static CURLcode test_lib555(const char *URL)
     FD_ZERO(&fdwrite);
     FD_ZERO(&fdexcep);
 
-    multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -138,8 +138,8 @@ test_cleanup:
 
   /* proper cleanup sequence - type PA */
 
-  curl_multi_remove_handle(m, curl);
-  curl_multi_cleanup(m);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
   curl_easy_cleanup(curl);
   curl_global_cleanup();
 

tests/libtest/lib560.c

@@ -37,8 +37,8 @@
  */
 static CURLcode test_lib560(const char *URL)
 {
-  CURL *http_handle = NULL;
-  CURLM *multi_handle = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
 
   int still_running; /* keep number of running handles */
@@ -49,22 +49,22 @@ static CURLcode test_lib560(const char *URL)
   ** curl_global_init called indirectly from curl_easy_init.
   */
 
-  easy_init(http_handle);
+  easy_init(curl);
 
   /* set options */
-  easy_setopt(http_handle, CURLOPT_URL, URL);
-  easy_setopt(http_handle, CURLOPT_HEADER, 1L);
-  easy_setopt(http_handle, CURLOPT_SSL_VERIFYPEER, 0L);
-  easy_setopt(http_handle, CURLOPT_SSL_VERIFYHOST, 0L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+  easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
 
   /* init a multi stack */
-  multi_init(multi_handle);
+  multi_init(multi);
 
   /* add the individual transfers */
-  multi_add_handle(multi_handle, http_handle);
+  multi_add_handle(multi, curl);
 
   /* we start some action by calling perform right away */
-  multi_perform(multi_handle, &still_running);
+  multi_perform(multi, &still_running);
 
   abort_on_test_timeout();
 
@@ -85,7 +85,7 @@ static CURLcode test_lib560(const char *URL)
     timeout.tv_usec = 0;
 
     /* get file descriptors from the transfers */
-    multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -94,7 +94,7 @@ static CURLcode test_lib560(const char *URL)
     abort_on_test_timeout();
 
     /* timeout or readable/writable sockets */
-    multi_perform(multi_handle, &still_running);
+    multi_perform(multi, &still_running);
 
     abort_on_test_timeout();
   }
@@ -103,8 +103,8 @@ test_cleanup:
 
   /* undocumented cleanup sequence - type UA */
 
-  curl_multi_cleanup(multi_handle);
-  curl_easy_cleanup(http_handle);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib564.c

@@ -31,7 +31,7 @@ static CURLcode test_lib564(const char *URL)
   CURLcode res = CURLE_OK;
   CURL *curl = NULL;
   int running;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
@@ -49,9 +49,9 @@ static CURLcode test_lib564(const char *URL)
   easy_setopt(curl, CURLOPT_PROXY, libtest_arg2);
   easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
   curl_mfprintf(stderr, "Start at URL 0\n");
 
@@ -63,7 +63,7 @@ static CURLcode test_lib564(const char *URL)
     interval.tv_sec = 1;
     interval.tv_usec = 0;
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -74,7 +74,7 @@ static CURLcode test_lib564(const char *URL)
     FD_ZERO(&wr);
     FD_ZERO(&exc);
 
-    multi_fdset(m, &rd, &wr, &exc, &maxfd);
+    multi_fdset(multi, &rd, &wr, &exc, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -88,7 +88,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UB */
 
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib573.c

@@ -32,8 +32,8 @@
 
 static CURLcode test_lib573(const char *URL)
 {
-  CURL *c = NULL;
-  CURLM *m = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int running = 1;
   double connect_time = 0.0;
@@ -48,20 +48,20 @@ static CURLcode test_lib573(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(c);
+  easy_init(curl);
 
-  easy_setopt(c, CURLOPT_HEADER, 1L);
-  easy_setopt(c, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
   debug_config.nohex = TRUE;
   debug_config.tracetime = TRUE;
-  easy_setopt(c, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(c, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(c, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_add_handle(m, c);
+  multi_add_handle(multi, curl);
 
   while(running) {
     struct timeval timeout;
@@ -71,7 +71,7 @@ static CURLcode test_lib573(const char *URL)
     timeout.tv_sec = 0;
     timeout.tv_usec = 100000L; /* 100 ms */
 
-    multi_perform(m, &running);
+    multi_perform(multi, &running);
 
     abort_on_test_timeout();
 
@@ -82,7 +82,7 @@ static CURLcode test_lib573(const char *URL)
     FD_ZERO(&fdwrite);
     FD_ZERO(&fdexcep);
 
-    multi_fdset(m, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -91,7 +91,7 @@ static CURLcode test_lib573(const char *URL)
     abort_on_test_timeout();
   }
 
-  curl_easy_getinfo(c, CURLINFO_CONNECT_TIME, &connect_time);
+  curl_easy_getinfo(curl, CURLINFO_CONNECT_TIME, &connect_time);
   if(connect_time < dbl_epsilon) {
     curl_mfprintf(stderr, "connect time %e is < epsilon %e\n",
                   connect_time, dbl_epsilon);
@@ -102,9 +102,9 @@ test_cleanup:
 
   /* proper cleanup sequence - type PA */
 
-  curl_multi_remove_handle(m, c);
-  curl_multi_cleanup(m);
-  curl_easy_cleanup(c);
+  curl_multi_remove_handle(multi, curl);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib575.c

@@ -33,9 +33,9 @@
 
 static CURLcode test_lib575(const char *URL)
 {
-  CURL *handle = NULL;
-  CURL *duphandle = NULL;
-  CURLM *mhandle = NULL;
+  CURL *curl = NULL;
+  CURL *curldupe = NULL;
+  CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int still_running = 0;
 
@@ -43,31 +43,31 @@ static CURLcode test_lib575(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(handle);
+  easy_init(curl);
 
-  easy_setopt(handle, CURLOPT_URL, URL);
-  easy_setopt(handle, CURLOPT_WILDCARDMATCH, 1L);
-  easy_setopt(handle, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_WILDCARDMATCH, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
-  duphandle = curl_easy_duphandle(handle);
-  if(!duphandle)
+  curldupe = curl_easy_duphandle(curl);
+  if(!curldupe)
     goto test_cleanup;
-  curl_easy_cleanup(handle);
-  handle = duphandle;
+  curl_easy_cleanup(curl);
+  curl = curldupe;
 
-  multi_init(mhandle);
+  multi_init(multi);
 
-  multi_add_handle(mhandle, handle);
+  multi_add_handle(multi, curl);
 
-  multi_perform(mhandle, &still_running);
+  multi_perform(multi, &still_running);
 
   abort_on_test_timeout();
 
@@ -85,7 +85,7 @@ static CURLcode test_lib575(const char *URL)
     FD_ZERO(&fdwrite);
     FD_ZERO(&fdexcep);
 
-    multi_fdset(mhandle, &fdread, &fdwrite, &fdexcep, &maxfd);
+    multi_fdset(multi, &fdread, &fdwrite, &fdexcep, &maxfd);
 
     /* At this point, maxfd is guaranteed to be greater or equal than -1. */
 
@@ -93,7 +93,7 @@ static CURLcode test_lib575(const char *URL)
 
     abort_on_test_timeout();
 
-    multi_perform(mhandle, &still_running);
+    multi_perform(multi, &still_running);
 
     abort_on_test_timeout();
   }
@@ -102,8 +102,8 @@ test_cleanup:
 
   /* undocumented cleanup sequence - type UA */
 
-  curl_multi_cleanup(mhandle);
-  curl_easy_cleanup(handle);
+  curl_multi_cleanup(multi);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib576.c

@@ -98,27 +98,27 @@ static long chunk_end(void *ptr)
 
 static CURLcode test_lib576(const char *URL)
 {
-  CURL *handle = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   struct chunk_data chunk_data = {0, 0};
   curl_global_init(CURL_GLOBAL_ALL);
-  handle = curl_easy_init();
-  if(!handle) {
+  curl = curl_easy_init();
+  if(!curl) {
     res = CURLE_OUT_OF_MEMORY;
     goto test_cleanup;
   }
 
-  test_setopt(handle, CURLOPT_URL, URL);
-  test_setopt(handle, CURLOPT_WILDCARDMATCH, 1L);
-  test_setopt(handle, CURLOPT_CHUNK_BGN_FUNCTION, chunk_bgn);
-  test_setopt(handle, CURLOPT_CHUNK_END_FUNCTION, chunk_end);
-  test_setopt(handle, CURLOPT_CHUNK_DATA, &chunk_data);
+  test_setopt(curl, CURLOPT_URL, URL);
+  test_setopt(curl, CURLOPT_WILDCARDMATCH, 1L);
+  test_setopt(curl, CURLOPT_CHUNK_BGN_FUNCTION, chunk_bgn);
+  test_setopt(curl, CURLOPT_CHUNK_END_FUNCTION, chunk_end);
+  test_setopt(curl, CURLOPT_CHUNK_DATA, &chunk_data);
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
-  if(handle)
-    curl_easy_cleanup(handle);
+  if(curl)
+    curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res;
 }

tests/libtest/lib582.c

@@ -92,12 +92,12 @@ static void t582_addFd(struct t582_Sockets *sockets, curl_socket_t fd,
 /**
  * Callback invoked by curl to poll reading / writing of a socket.
  */
-static int t582_curlSocketCallback(CURL *easy, curl_socket_t s, int action,
+static int t582_curlSocketCallback(CURL *curl, curl_socket_t s, int action,
                                    void *userp, void *socketp)
 {
   struct t582_ReadWriteSockets *sockets = userp;
 
-  (void)easy;
+  (void)curl;
   (void)socketp;
 
   if(action == CURL_POLL_IN || action == CURL_POLL_INOUT)
@@ -135,13 +135,13 @@ static int t582_curlTimerCallback(CURLM *multi, long timeout_ms, void *userp)
 /**
  * Check for curl completion.
  */
-static int t582_checkForCompletion(CURLM *curl, int *success)
+static int t582_checkForCompletion(CURLM *multi, int *success)
 {
   int result = 0;
   *success = 0;
   while(1) {
     int numMessages;
-    CURLMsg *message = curl_multi_info_read(curl, &numMessages);
+    CURLMsg *message = curl_multi_info_read(multi, &numMessages);
     if(!message)
       break;
     if(message->msg == CURLMSG_DONE) {
@@ -196,11 +196,12 @@ static void t582_updateFdSet(struct t582_Sockets *sockets, fd_set* fdset,
   }
 }
 
-static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask,
+static void notifyCurl(CURLM *multi, curl_socket_t s, int evBitmask,
                        const char *info)
 {
   int numhandles = 0;
-  CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
+  CURLMcode result = curl_multi_socket_action(multi, s, evBitmask,
+                                              &numhandles);
   if(result != CURLM_OK) {
     curl_mfprintf(stderr, "Curl error on %s (%i) %s\n",
                   info, result, curl_multi_strerror(result));
@@ -210,13 +211,13 @@ static void notifyCurl(CURLM *curl, curl_socket_t s, int evBitmask,
 /**
  * Invoke curl when a file descriptor is set.
  */
-static void t582_checkFdSet(CURLM *curl, struct t582_Sockets *sockets,
+static void t582_checkFdSet(CURLM *multi, struct t582_Sockets *sockets,
                             fd_set *fdset, int evBitmask, const char *name)
 {
   int i;
   for(i = 0; i < sockets->count; ++i) {
     if(FD_ISSET(sockets->sockets[i], fdset)) {
-      notifyCurl(curl, sockets->sockets[i], evBitmask, name);
+      notifyCurl(multi, sockets->sockets[i], evBitmask, name);
     }
   }
 }
@@ -229,7 +230,7 @@ static CURLcode test_lib582(const char *URL)
   FILE *hd_src = NULL;
   int hd;
   struct_stat file_info;
-  CURLM *m = NULL;
+  CURLM *multi = NULL;
   struct t582_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}};
   int success = 0;
   struct curltime timeout = {0};
@@ -297,17 +298,17 @@ static CURLcode test_lib582(const char *URL)
 
   easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t582_curlSocketCallback);
-  multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
+  multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t582_curlSocketCallback);
+  multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets);
 
-  multi_setopt(m, CURLMOPT_TIMERFUNCTION, t582_curlTimerCallback);
-  multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
+  multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t582_curlTimerCallback);
+  multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
-  while(!t582_checkForCompletion(m, &success)) {
+  while(!t582_checkForCompletion(multi, &success)) {
     fd_set readSet, writeSet;
     curl_socket_t maxFd = 0;
     struct timeval tv = {0};
@@ -331,13 +332,15 @@ static CURLcode test_lib582(const char *URL)
     select_test((int)maxFd, &readSet, &writeSet, NULL, &tv);
 
     /* Check the sockets for reading / writing */
-    t582_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN, "read");
-    t582_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT, "write");
+    t582_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN,
+                    "read");
+    t582_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT,
+                    "write");
 
     if(timeout.tv_sec != (time_t)-1 &&
        t582_getMicroSecondTimeout(&timeout) == 0) {
       /* Curl's timer has elapsed. */
-      notifyCurl(m, CURL_SOCKET_TIMEOUT, 0, "timeout");
+      notifyCurl(multi, CURL_SOCKET_TIMEOUT, 0, "timeout");
     }
 
     abort_on_test_timeout();
@@ -352,9 +355,9 @@ test_cleanup:
 
   /* proper cleanup sequence - type PB */
 
-  curl_multi_remove_handle(m, curl);
+  curl_multi_remove_handle(multi, curl);
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   /* close the local file */

tests/libtest/lib583.c

@@ -33,7 +33,7 @@
 static CURLcode test_lib583(const char *URL)
 {
   int stillRunning;
-  CURLM *multiHandle = NULL;
+  CURLM *multi = NULL;
   CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   CURLMcode mres;
@@ -42,7 +42,7 @@ static CURLcode test_lib583(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  multi_init(multiHandle);
+  multi_init(multi);
 
   easy_init(curl);
 
@@ -56,19 +56,19 @@ static CURLcode test_lib583(const char *URL)
   easy_setopt(curl, CURLOPT_URL, URL);
   easy_setopt(curl, CURLOPT_INFILESIZE, 5L);
 
-  multi_add_handle(multiHandle, curl);
+  multi_add_handle(multi, curl);
 
   /* this tests if removing an easy handle immediately after multi
      perform has been called succeeds or not. */
 
   curl_mfprintf(stderr, "curl_multi_perform()...\n");
 
-  multi_perform(multiHandle, &stillRunning);
+  multi_perform(multi, &stillRunning);
 
   curl_mfprintf(stderr, "curl_multi_perform() succeeded\n");
 
   curl_mfprintf(stderr, "curl_multi_remove_handle()...\n");
-  mres = curl_multi_remove_handle(multiHandle, curl);
+  mres = curl_multi_remove_handle(multi, curl);
   if(mres) {
     curl_mfprintf(stderr, "curl_multi_remove_handle() failed, with code %d\n",
                   mres);
@@ -82,7 +82,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UB */
 
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(multiHandle);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib586.c

@@ -39,13 +39,13 @@ struct t586_userdata {
 };
 
 /* lock callback */
-static void t586_test_lock(CURL *handle, curl_lock_data data,
+static void t586_test_lock(CURL *curl, curl_lock_data data,
                            curl_lock_access laccess, void *useptr)
 {
   const char *what;
   struct t586_userdata *user = (struct t586_userdata *)useptr;
 
-  (void)handle;
+  (void)curl;
   (void)laccess;
 
   switch(data) {
@@ -70,11 +70,11 @@ static void t586_test_lock(CURL *handle, curl_lock_data data,
 }
 
 /* unlock callback */
-static void t586_test_unlock(CURL *handle, curl_lock_data data, void *useptr)
+static void t586_test_unlock(CURL *curl, curl_lock_data data, void *useptr)
 {
   const char *what;
   struct t586_userdata *user = (struct t586_userdata *)useptr;
-  (void)handle;
+  (void)curl;
   switch(data) {
     case CURL_LOCK_DATA_SHARE:
       what = "share";

tests/libtest/lib591.c

@@ -29,7 +29,7 @@
 
 static CURLcode test_lib591(const char *URL)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int running;
@@ -54,29 +54,29 @@ static CURLcode test_lib591(const char *URL)
     return res;
   }
 
-  easy_init(easy);
+  easy_init(curl);
 
   /* go verbose */
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   /* specify target */
-  easy_setopt(easy, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
   /* enable uploading */
-  easy_setopt(easy, CURLOPT_UPLOAD, 1L);
+  easy_setopt(curl, CURLOPT_UPLOAD, 1L);
 
   /* data pointer for the file read function */
-  easy_setopt(easy, CURLOPT_READDATA, upload);
+  easy_setopt(curl, CURLOPT_READDATA, upload);
 
   /* use active mode FTP */
-  easy_setopt(easy, CURLOPT_FTPPORT, "-");
+  easy_setopt(curl, CURLOPT_FTPPORT, "-");
 
   /* server connection timeout */
-  easy_setopt(easy, CURLOPT_ACCEPTTIMEOUT_MS, atol(libtest_arg2)*1000);
+  easy_setopt(curl, CURLOPT_ACCEPTTIMEOUT_MS, atol(libtest_arg2)*1000);
 
   multi_init(multi);
 
-  multi_add_handle(multi, easy);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval interval;
@@ -134,7 +134,7 @@ test_cleanup:
   /* undocumented cleanup sequence - type UA */
 
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   /* close the local file */

tests/libtest/lib597.c

@@ -36,7 +36,7 @@
 
 static CURLcode test_lib597(const char *URL)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLM *multi = NULL;
   CURLcode res = CURLE_OK;
   int running;
@@ -47,19 +47,19 @@ static CURLcode test_lib597(const char *URL)
 
   global_init(CURL_GLOBAL_ALL);
 
-  easy_init(easy);
+  easy_init(curl);
 
   multi_init(multi);
 
   /* go verbose */
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   /* specify target */
-  easy_setopt(easy, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_URL, URL);
 
-  easy_setopt(easy, CURLOPT_CONNECT_ONLY, 1L);
+  easy_setopt(curl, CURLOPT_CONNECT_ONLY, 1L);
 
-  multi_add_handle(multi, easy);
+  multi_add_handle(multi, curl);
 
   for(;;) {
     struct timeval interval;
@@ -113,14 +113,14 @@ static CURLcode test_lib597(const char *URL)
   if(msg)
     res = msg->data.result;
 
-  multi_remove_handle(multi, easy);
+  multi_remove_handle(multi, curl);
 
 test_cleanup:
 
   /* undocumented cleanup sequence - type UA */
 
   curl_multi_cleanup(multi);
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib643.c

@@ -225,13 +225,13 @@ test_cleanup:
 
 static CURLcode t643_cyclic_add(void)
 {
-  CURL *easy = curl_easy_init();
-  curl_mime *mime = curl_mime_init(easy);
+  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);
 
   if(a1 == CURLE_BAD_FUNCTION_ARGUMENT) {
-    curl_mime *submime = curl_mime_init(easy);
+    curl_mime *submime = curl_mime_init(curl);
     curl_mimepart *subpart = curl_mime_addpart(submime);
 
     curl_mime_subparts(part, submime);
@@ -239,7 +239,7 @@ static CURLcode t643_cyclic_add(void)
   }
 
   curl_mime_free(mime);
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   if(a1 != CURLE_BAD_FUNCTION_ARGUMENT)
     /* that should have failed */
     return TEST_ERR_FAILURE;

tests/libtest/lib653.c

@@ -27,36 +27,36 @@
 
 static CURLcode test_lib653(const char *URL)
 {
-  CURL *curls = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   curl_mimepart *field = NULL;
   curl_mime *mime = NULL;
 
   global_init(CURL_GLOBAL_ALL);
-  easy_init(curls);
+  easy_init(curl);
 
-  mime = curl_mime_init(curls);
+  mime = curl_mime_init(curl);
   field = curl_mime_addpart(mime);
   curl_mime_name(field, "name");
   curl_mime_data(field, "short value", CURL_ZERO_TERMINATED);
 
-  easy_setopt(curls, CURLOPT_URL, URL);
-  easy_setopt(curls, CURLOPT_HEADER, 1L);
-  easy_setopt(curls, CURLOPT_VERBOSE, 1L);
-  easy_setopt(curls, CURLOPT_MIMEPOST, mime);
-  easy_setopt(curls, CURLOPT_NOPROGRESS, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_HEADER, 1L);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_MIMEPOST, mime);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
 
-  res = curl_easy_perform(curls);
+  res = curl_easy_perform(curl);
   if(res)
     goto test_cleanup;
 
   /* Alter form and resubmit. */
   curl_mime_data(field, "long value for length change", CURL_ZERO_TERMINATED);
-  res = curl_easy_perform(curls);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
   curl_mime_free(mime);
-  curl_easy_cleanup(curls);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
   return res; /* return the final return code */
 }

tests/libtest/lib654.c

@@ -63,8 +63,8 @@ static CURLcode test_lib654(const char *URL)
 {
   static const char testdata[] = "dummy\n";
 
-  CURL *easy = NULL;
-  CURL *easy2 = NULL;
+  CURL *curl = NULL;
+  CURL *curl2 = NULL;
   curl_mime *mime = NULL;
   curl_mimepart *part;
   struct curl_slist *hdrs = NULL;
@@ -81,16 +81,16 @@ static CURLcode test_lib654(const char *URL)
     return TEST_ERR_MAJOR_BAD;
   }
 
-  easy = curl_easy_init();
+  curl = curl_easy_init();
 
   /* First set the URL that is about to receive our POST. */
-  test_setopt(easy, CURLOPT_URL, URL);
+  test_setopt(curl, CURLOPT_URL, URL);
 
   /* get verbose debug output please */
-  test_setopt(easy, CURLOPT_VERBOSE, 1L);
+  test_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   /* include headers in the output */
-  test_setopt(easy, CURLOPT_HEADER, 1L);
+  test_setopt(curl, CURLOPT_HEADER, 1L);
 
   /* Prepare the callback structure. */
   pooh.readptr = testdata;
@@ -98,7 +98,7 @@ static CURLcode test_lib654(const char *URL)
   pooh.freecount = 0;
 
   /* Build the mime tree. */
-  mime = curl_mime_init(easy);
+  mime = curl_mime_init(curl);
   part = curl_mime_addpart(mime);
   curl_mime_data(part, "hello", CURL_ZERO_TERMINATED);
   curl_mime_name(part, "greeting");
@@ -113,11 +113,11 @@ static CURLcode test_lib654(const char *URL)
                     free_callback, &pooh);
 
   /* Bind mime data to its easy handle. */
-  test_setopt(easy, CURLOPT_MIMEPOST, mime);
+  test_setopt(curl, CURLOPT_MIMEPOST, mime);
 
   /* Duplicate the handle. */
-  easy2 = curl_easy_duphandle(easy);
-  if(!easy2) {
+  curl2 = curl_easy_duphandle(curl);
+  if(!curl2) {
     curl_mfprintf(stderr, "curl_easy_duphandle() failed\n");
     res = TEST_ERR_FAILURE;
     goto test_cleanup;
@@ -129,7 +129,7 @@ static CURLcode test_lib654(const char *URL)
   mime = NULL;  /* Already cleaned up. */
 
   /* Perform on the first handle: should not send any data. */
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res != CURLE_OK) {
     curl_mfprintf(stderr, "curl_easy_perform(original) failed\n");
     goto test_cleanup;
@@ -137,7 +137,7 @@ static CURLcode test_lib654(const char *URL)
 
   /* Perform on the second handle: if the bound mime structure has not been
      duplicated properly, it should cause a valgrind error. */
-  res = curl_easy_perform(easy2);
+  res = curl_easy_perform(curl2);
   if(res != CURLE_OK) {
     curl_mfprintf(stderr, "curl_easy_perform(duplicated) failed\n");
     goto test_cleanup;
@@ -146,8 +146,8 @@ static CURLcode test_lib654(const char *URL)
   /* Free the duplicated handle: it should call free_callback again.
      If the mime copy was bad or not automatically released, valgrind
      will signal it. */
-  curl_easy_cleanup(easy2);
-  easy2 = NULL;  /* Already cleaned up. */
+  curl_easy_cleanup(curl2);
+  curl2 = NULL;  /* Already cleaned up. */
 
   if(pooh.freecount != 2) {
     curl_mfprintf(stderr, "free_callback() called %d times instead of 2\n",
@@ -157,8 +157,8 @@ static CURLcode test_lib654(const char *URL)
   }
 
 test_cleanup:
-  curl_easy_cleanup(easy);
-  curl_easy_cleanup(easy2);
+  curl_easy_cleanup(curl);
+  curl_easy_cleanup(curl2);
   curl_mime_free(mime);
   curl_global_cleanup();
   return res;

tests/libtest/lib658.c

@@ -31,13 +31,13 @@
 
 static CURLcode test_lib658(const char *URL)
 {
-  CURL *handle = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   CURLU *urlp = NULL;
   CURLUcode uc = CURLUE_OK;
 
   global_init(CURL_GLOBAL_ALL);
-  easy_init(handle);
+  easy_init(curl);
 
   urlp = curl_url();
 
@@ -54,12 +54,12 @@ static CURLcode test_lib658(const char *URL)
   }
 
   /* demonstrate override behavior */
-  easy_setopt(handle, CURLOPT_URL, "http://www.example.com");
+  easy_setopt(curl, CURLOPT_URL, "http://www.example.com");
 
-  easy_setopt(handle, CURLOPT_CURLU, urlp);
-  easy_setopt(handle, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_CURLU, urlp);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
 
   if(res) {
     curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
@@ -71,7 +71,7 @@ static CURLcode test_lib658(const char *URL)
 test_cleanup:
 
   curl_url_cleanup(urlp);
-  curl_easy_cleanup(handle);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib659.c

@@ -31,12 +31,12 @@
 
 static CURLcode test_lib659(const char *URL)
 {
-  CURL *handle = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
   CURLU *urlp = NULL;
 
   global_init(CURL_GLOBAL_ALL);
-  easy_init(handle);
+  easy_init(curl);
 
   urlp = curl_url();
 
@@ -53,11 +53,11 @@ static CURLcode test_lib659(const char *URL)
     goto test_cleanup;
   }
 
-  easy_setopt(handle, CURLOPT_CURLU, urlp);
-  easy_setopt(handle, CURLOPT_VERBOSE, 1L);
-  easy_setopt(handle, CURLOPT_PROXY, URL);
+  easy_setopt(curl, CURLOPT_CURLU, urlp);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_PROXY, URL);
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
 
   if(res) {
     curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
@@ -69,7 +69,7 @@ static CURLcode test_lib659(const char *URL)
 test_cleanup:
 
   curl_url_cleanup(urlp);
-  curl_easy_cleanup(handle);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib667.c

@@ -55,7 +55,7 @@ static CURLcode test_lib667(const char *URL)
 {
   static const char testdata[] = "dummy";
 
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   curl_mime *mime = NULL;
   curl_mimepart *part;
   CURLcode res = TEST_ERR_FAILURE;
@@ -71,23 +71,23 @@ static CURLcode test_lib667(const char *URL)
     return TEST_ERR_MAJOR_BAD;
   }
 
-  easy = curl_easy_init();
+  curl = curl_easy_init();
 
   /* First set the URL that is about to receive our POST. */
-  test_setopt(easy, CURLOPT_URL, URL);
+  test_setopt(curl, CURLOPT_URL, URL);
 
   /* get verbose debug output please */
-  test_setopt(easy, CURLOPT_VERBOSE, 1L);
+  test_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   /* include headers in the output */
-  test_setopt(easy, CURLOPT_HEADER, 1L);
+  test_setopt(curl, CURLOPT_HEADER, 1L);
 
   /* Prepare the callback structure. */
   pooh.readptr = testdata;
   pooh.sizeleft = (curl_off_t) strlen(testdata);
 
   /* Build the mime tree. */
-  mime = curl_mime_init(easy);
+  mime = curl_mime_init(curl);
   part = curl_mime_addpart(mime);
   curl_mime_name(part, "field");
   curl_mime_encoder(part, "base64");
@@ -96,16 +96,16 @@ static CURLcode test_lib667(const char *URL)
                     NULL, NULL, &pooh);
 
   /* Bind mime data to its easy handle. */
-  test_setopt(easy, CURLOPT_MIMEPOST, mime);
+  test_setopt(curl, CURLOPT_MIMEPOST, mime);
 
   /* Send data. */
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res != CURLE_OK) {
     curl_mfprintf(stderr, "curl_easy_perform() failed\n");
   }
 
 test_cleanup:
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_mime_free(mime);
   curl_global_cleanup();
   return res;

tests/libtest/lib668.c

@@ -50,7 +50,7 @@ static CURLcode test_lib668(const char *URL)
 {
   static const char testdata[] = "dummy";
 
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   curl_mime *mime = NULL;
   curl_mimepart *part;
   CURLcode res = TEST_ERR_FAILURE;
@@ -65,16 +65,16 @@ static CURLcode test_lib668(const char *URL)
     return TEST_ERR_MAJOR_BAD;
   }
 
-  easy = curl_easy_init();
+  curl = curl_easy_init();
 
   /* First set the URL that is about to receive our POST. */
-  test_setopt(easy, CURLOPT_URL, URL);
+  test_setopt(curl, CURLOPT_URL, URL);
 
   /* get verbose debug output please */
-  test_setopt(easy, CURLOPT_VERBOSE, 1L);
+  test_setopt(curl, CURLOPT_VERBOSE, 1L);
 
   /* include headers in the output */
-  test_setopt(easy, CURLOPT_HEADER, 1L);
+  test_setopt(curl, CURLOPT_HEADER, 1L);
 
   /* Prepare the callback structures. */
   pooh1.readptr = testdata;
@@ -82,7 +82,7 @@ static CURLcode test_lib668(const char *URL)
   pooh2 = pooh1;
 
   /* Build the mime tree. */
-  mime = curl_mime_init(easy);
+  mime = curl_mime_init(curl);
   part = curl_mime_addpart(mime);
   curl_mime_name(part, "field1");
   /* Early end of data detection can be done because the data size is known. */
@@ -101,16 +101,16 @@ static CURLcode test_lib668(const char *URL)
   curl_mime_filedata(part, libtest_arg2);
 
   /* Bind mime data to its easy handle. */
-  test_setopt(easy, CURLOPT_MIMEPOST, mime);
+  test_setopt(curl, CURLOPT_MIMEPOST, mime);
 
   /* Send data. */
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
   if(res != CURLE_OK) {
     curl_mfprintf(stderr, "curl_easy_perform() failed\n");
   }
 
 test_cleanup:
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_mime_free(mime);
   curl_global_cleanup();
   return res;

tests/libtest/lib670.c

@@ -28,7 +28,7 @@
 #define PAUSE_TIME      5
 
 struct t670_ReadThis {
-  CURL *easy;
+  CURL *curl;
   time_t origin;
   int count;
 };
@@ -79,7 +79,7 @@ static int t670_xferinfo(void *clientp,
     }
 
     if(delta >= PAUSE_TIME)
-      curl_easy_pause(pooh->easy, CURLPAUSE_CONT);
+      curl_easy_pause(pooh->curl, CURLPAUSE_CONT);
   }
 
   return 0;
@@ -106,21 +106,21 @@ static CURLcode test_lib670(const char *URL)
 
   pooh.origin = (time_t) 0;
   pooh.count = 0;
-  pooh.easy = curl_easy_init();
+  pooh.curl = curl_easy_init();
 
   /* First set the URL that is about to receive our POST. */
-  test_setopt(pooh.easy, CURLOPT_URL, URL);
+  test_setopt(pooh.curl, CURLOPT_URL, URL);
 
   /* get verbose debug output please */
-  test_setopt(pooh.easy, CURLOPT_VERBOSE, 1L);
+  test_setopt(pooh.curl, CURLOPT_VERBOSE, 1L);
 
   /* include headers in the output */
-  test_setopt(pooh.easy, CURLOPT_HEADER, 1L);
+  test_setopt(pooh.curl, CURLOPT_HEADER, 1L);
 
   if(testnum == 670 || testnum == 671) {
     curl_mimepart *part;
     /* Build the mime tree. */
-    mime = curl_mime_init(pooh.easy);
+    mime = curl_mime_init(pooh.curl);
     part = curl_mime_addpart(mime);
     res = curl_mime_name(part, testname);
     if(res != CURLE_OK) {
@@ -135,7 +135,7 @@ static CURLcode test_lib670(const char *URL)
 
     /* Bind mime data to its easy handle. */
     if(res == CURLE_OK)
-      test_setopt(pooh.easy, CURLOPT_MIMEPOST, mime);
+      test_setopt(pooh.curl, CURLOPT_MIMEPOST, mime);
   }
   else {
     struct curl_httppost *lastptr = NULL;
@@ -152,10 +152,10 @@ static CURLcode test_lib670(const char *URL)
     }
 
     /* We want to use our own read function. */
-    test_setopt(pooh.easy, CURLOPT_READFUNCTION, t670_read_cb);
+    test_setopt(pooh.curl, CURLOPT_READFUNCTION, t670_read_cb);
 
     /* Send a multi-part formpost. */
-    test_setopt(pooh.easy, CURLOPT_HTTPPOST, formpost);
+    test_setopt(pooh.curl, CURLOPT_HTTPPOST, formpost);
   }
 
   if(testnum == 670 || testnum == 672) {
@@ -163,7 +163,7 @@ static CURLcode test_lib670(const char *URL)
     CURLM *multi;
     /* Use the multi interface. */
     multi = curl_multi_init();
-    mres = curl_multi_add_handle(multi, pooh.easy);
+    mres = curl_multi_add_handle(multi, pooh.curl);
     while(!mres) {
       struct timeval timeout;
       int rc = 0;
@@ -187,7 +187,7 @@ static CURLcode test_lib670(const char *URL)
         }
 
         if(delta >= PAUSE_TIME)
-          curl_easy_pause(pooh.easy, CURLPAUSE_CONT);
+          curl_easy_pause(pooh.curl, CURLPAUSE_CONT);
       }
 
       FD_ZERO(&fdread);
@@ -222,19 +222,19 @@ static CURLcode test_lib670(const char *URL)
         }
       }
 
-    curl_multi_remove_handle(multi, pooh.easy);
+    curl_multi_remove_handle(multi, pooh.curl);
     curl_multi_cleanup(multi);
   }
   else {
     /* Use the easy interface. */
-    test_setopt(pooh.easy, CURLOPT_XFERINFODATA, &pooh);
-    test_setopt(pooh.easy, CURLOPT_XFERINFOFUNCTION, t670_xferinfo);
-    test_setopt(pooh.easy, CURLOPT_NOPROGRESS, 0L);
-    res = curl_easy_perform(pooh.easy);
+    test_setopt(pooh.curl, CURLOPT_XFERINFODATA, &pooh);
+    test_setopt(pooh.curl, CURLOPT_XFERINFOFUNCTION, t670_xferinfo);
+    test_setopt(pooh.curl, CURLOPT_NOPROGRESS, 0L);
+    res = curl_easy_perform(pooh.curl);
   }
 
 test_cleanup:
-  curl_easy_cleanup(pooh.easy);
+  curl_easy_cleanup(pooh.curl);
 
   if(testnum == 670 || testnum == 671) {
     curl_mime_free(mime);

tests/libtest/lib674.c

@@ -31,14 +31,14 @@
 
 static CURLcode test_lib674(const char *URL)
 {
-  CURL *handle = NULL;
-  CURL *handle2;
+  CURL *curl = NULL;
+  CURL *curl2;
   CURLcode res = CURLE_OK;
   CURLU *urlp = NULL;
   CURLUcode uc = CURLUE_OK;
 
   global_init(CURL_GLOBAL_ALL);
-  easy_init(handle);
+  easy_init(curl);
 
   urlp = curl_url();
 
@@ -56,10 +56,10 @@ static CURLcode test_lib674(const char *URL)
 
   /* demonstrate override behavior */
 
-  easy_setopt(handle, CURLOPT_CURLU, urlp);
-  easy_setopt(handle, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_CURLU, urlp);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  res = curl_easy_perform(handle);
+  res = curl_easy_perform(curl);
 
   if(res) {
     curl_mfprintf(stderr, "%s:%d curl_easy_perform() failed "
@@ -68,14 +68,14 @@ static CURLcode test_lib674(const char *URL)
     goto test_cleanup;
   }
 
-  handle2 = curl_easy_duphandle(handle);
-  res = curl_easy_perform(handle2);
-  curl_easy_cleanup(handle2);
+  curl2 = curl_easy_duphandle(curl);
+  res = curl_easy_perform(curl2);
+  curl_easy_cleanup(curl2);
 
 test_cleanup:
 
   curl_url_cleanup(urlp);
-  curl_easy_cleanup(handle);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib678.c

@@ -99,15 +99,14 @@ static CURLcode test_lib678(const char *URL)
   CURLcode res = CURLE_OK;
   curl_global_init(CURL_GLOBAL_DEFAULT);
   if(!strcmp("check", URL)) {
-    CURL *e;
     CURLcode w = CURLE_OK;
     struct curl_blob blob = {0};
-    e = curl_easy_init();
-    if(e) {
-      w = curl_easy_setopt(e, CURLOPT_CAINFO_BLOB, &blob);
+    CURL *curl = curl_easy_init();
+    if(curl) {
+      w = curl_easy_setopt(curl, CURLOPT_CAINFO_BLOB, &blob);
       if(w)
         curl_mprintf("CURLOPT_CAINFO_BLOB is not supported\n");
-      curl_easy_cleanup(e);
+      curl_easy_cleanup(curl);
     }
     res = w;
   }

tests/libtest/lib751.c

@@ -31,37 +31,37 @@
 
 static CURLcode test_lib751(const char *URL)
 {
-  CURL *easies[1000];
-  CURLM *m;
+  CURL *curls[1000];
+  CURLM *multi;
   CURLcode res = CURLE_FAILED_INIT;
   CURLMcode mres;
   int i;
 
   (void)URL;
-  memset(easies, 0, sizeof(easies));
+  memset(curls, 0, sizeof(curls));
 
   curl_global_init(CURL_GLOBAL_DEFAULT);
-  m = curl_multi_init();
-  if(!m) {
+  multi = curl_multi_init();
+  if(!multi) {
     res = CURLE_OUT_OF_MEMORY;
     goto test_cleanup;
   }
 
   for(i = 0; i < 1000; i++) {
-    CURL *e = curl_easy_init();
-    if(!e) {
+    CURL *curl = curl_easy_init();
+    if(!curl) {
       res = CURLE_OUT_OF_MEMORY;
       goto test_cleanup;
     }
-    easies[i] = e;
+    curls[i] = curl;
 
-    res = curl_easy_setopt(e, CURLOPT_URL, "https://www.example.com/");
+    res = curl_easy_setopt(curl, CURLOPT_URL, "https://www.example.com/");
     if(!res)
-      res = curl_easy_setopt(e, CURLOPT_VERBOSE, 1L);
+      res = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
     if(res)
       goto test_cleanup;
 
-    mres = curl_multi_add_handle(m, e);
+    mres = curl_multi_add_handle(multi, curl);
     if(mres != CURLM_OK) {
       curl_mfprintf(stderr, "MULTI ERROR: %s\n", curl_multi_strerror(mres));
       res = CURLE_FAILED_INIT;
@@ -75,13 +75,13 @@ test_cleanup:
     curl_mfprintf(stderr, "ERROR: %s\n", curl_easy_strerror(res));
 
   for(i = 0; i < 1000; i++) {
-    if(easies[i]) {
-      curl_multi_add_handle(m, easies[i]);
-      curl_easy_cleanup(easies[i]);
-      easies[i] = NULL;
+    if(curls[i]) {
+      curl_multi_add_handle(multi, curls[i]);
+      curl_easy_cleanup(curls[i]);
+      curls[i] = NULL;
     }
   }
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   return res;

tests/libtest/lib753.c

@@ -27,7 +27,7 @@
 #include "memdebug.h"
 
 struct t753_transfer_status {
-  CURL *easy;
+  CURL *curl;
   const char *name;
   bool pause;
   bool is_paused;
@@ -56,49 +56,49 @@ static size_t t753_hd_cb(char *ptr, size_t size, size_t nmemb, void *userp)
   curl_mfprintf(stderr, "[%s] hd_cb '%.*s'\n", st->name, (int)len, ptr);
   if(!strcmp("230 Welcome you silly person\r\n", ptr)) {
     st->seen_welcome = TRUE;
-    st->easy = NULL;
+    st->curl = NULL;
   }
   return len;
 }
 
 static bool t753_setup(const char *URL, const char *name,
-                       CURL **peasy,
+                       CURL **pcurl,
                        struct t753_transfer_status *st)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
 
-  *peasy = NULL;
+  *pcurl = NULL;
   memset(st, 0, sizeof(*st));
   st->name = name;
-  st->easy = easy;
+  st->curl = curl;
   st->pause = TRUE;
 
-  easy_init(easy);
+  easy_init(curl);
 
-  easy_setopt(easy, CURLOPT_URL, URL);
-  easy_setopt(easy, CURLOPT_WRITEFUNCTION, t753_write_cb);
-  easy_setopt(easy, CURLOPT_WRITEDATA, st);
-  easy_setopt(easy, CURLOPT_HEADERFUNCTION, t753_hd_cb);
-  easy_setopt(easy, CURLOPT_HEADERDATA, st);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_WRITEFUNCTION, t753_write_cb);
+  easy_setopt(curl, CURLOPT_WRITEDATA, st);
+  easy_setopt(curl, CURLOPT_HEADERFUNCTION, t753_hd_cb);
+  easy_setopt(curl, CURLOPT_HEADERDATA, st);
 
-  easy_setopt(easy, CURLOPT_NOPROGRESS, 1L);
-  easy_setopt(easy, CURLOPT_DEBUGDATA, &debug_config);
-  easy_setopt(easy, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+  easy_setopt(curl, CURLOPT_DEBUGDATA, &debug_config);
+  easy_setopt(curl, CURLOPT_DEBUGFUNCTION, libtest_debug_cb);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 
-  *peasy = easy;
+  *pcurl = curl;
   return TRUE;
 
 test_cleanup:
-  if(easy)
-    curl_easy_cleanup(easy);
+  if(curl)
+    curl_easy_cleanup(curl);
   return FALSE;
 }
 
 static CURLcode test_lib753(const char *URL)
 {
-  CURL *easy1 = NULL, *easy2 = NULL;
+  CURL *curl1 = NULL, *curl2 = NULL;
   CURLM *multi = NULL;
   struct t753_transfer_status st1, st2;
   CURLcode res = CURLE_OK;
@@ -119,10 +119,10 @@ static CURLcode test_lib753(const char *URL)
     goto test_cleanup;
   }
 
-  if(!t753_setup(URL, "EASY1", &easy1, &st1))
+  if(!t753_setup(URL, "EASY1", &curl1, &st1))
     goto test_cleanup;
 
-  multi_add_handle(multi, easy1);
+  multi_add_handle(multi, curl1);
 
   multi_perform(multi, &still_running);
   abort_on_test_timeout();
@@ -142,14 +142,14 @@ static CURLcode test_lib753(const char *URL)
      *    that the connection is NOT reused, e.g. all FTP commands
      *    are sent again on the new connection.
      */
-    if(easy1 && st1.seen_welcome) {
-      curl_easy_cleanup(easy1);
-      easy1 = NULL;
-      if(!easy2) {
-        if(!t753_setup(URL, "EASY2", &easy2, &st2))
+    if(curl1 && st1.seen_welcome) {
+      curl_easy_cleanup(curl1);
+      curl1 = NULL;
+      if(!curl2) {
+        if(!t753_setup(URL, "EASY2", &curl2, &st2))
           goto test_cleanup;
         st2.pause = FALSE;
-        multi_add_handle(multi, easy2);
+        multi_add_handle(multi, curl2);
       }
     }
 
@@ -173,10 +173,10 @@ test_cleanup:
   if(res)
     curl_mfprintf(stderr, "ERROR: %s\n", curl_easy_strerror(res));
 
-  if(easy1)
-    curl_easy_cleanup(easy1);
-  if(easy2)
-    curl_easy_cleanup(easy2);
+  if(curl1)
+    curl_easy_cleanup(curl1);
+  if(curl2)
+    curl_easy_cleanup(curl2);
   curl_multi_cleanup(multi);
   curl_global_cleanup();
 

tests/libtest/lib758.c

@@ -146,12 +146,12 @@ static int t758_addFd(struct t758_Sockets *sockets, curl_socket_t fd,
 /**
  * Callback invoked by curl to poll reading / writing of a socket.
  */
-static int t758_curlSocketCallback(CURL *easy, curl_socket_t s, int action,
+static int t758_curlSocketCallback(CURL *curl, curl_socket_t s, int action,
                                    void *userp, void *socketp)
 {
   struct t758_ReadWriteSockets *sockets = userp;
 
-  (void)easy;
+  (void)curl;
   (void)socketp;
 
   t758_ctx.socket_calls++;
@@ -235,13 +235,13 @@ t758_set_ssl_ctx_callback(CURL *curl, void *ssl_ctx, void *clientp)
 /**
  * Check for curl completion.
  */
-static int t758_checkForCompletion(CURLM *curl, int *success)
+static int t758_checkForCompletion(CURLM *multi, int *success)
 {
   int result = 0;
   *success = 0;
   while(1) {
     int numMessages;
-    CURLMsg *message = curl_multi_info_read(curl, &numMessages);
+    CURLMsg *message = curl_multi_info_read(multi, &numMessages);
     if(!message)
       break;
     if(message->msg == CURLMSG_DONE) {
@@ -296,11 +296,12 @@ static void t758_updateFdSet(struct t758_Sockets *sockets, fd_set* fdset,
   }
 }
 
-static CURLMcode t758_saction(CURLM *curl, curl_socket_t s,
+static CURLMcode t758_saction(CURLM *multi, curl_socket_t s,
                               int evBitmask, const char *info)
 {
   int numhandles = 0;
-  CURLMcode result = curl_multi_socket_action(curl, s, evBitmask, &numhandles);
+  CURLMcode result = curl_multi_socket_action(multi, s, evBitmask,
+                                              &numhandles);
   if(result != CURLM_OK) {
     curl_mfprintf(stderr, "%s Curl error on %s (%i) %s\n",
                   t758_tag(), info, result, curl_multi_strerror(result));
@@ -311,7 +312,7 @@ static CURLMcode t758_saction(CURLM *curl, curl_socket_t s,
 /**
  * Invoke curl when a file descriptor is set.
  */
-static CURLMcode t758_checkFdSet(CURLM *curl, struct t758_Sockets *sockets,
+static CURLMcode t758_checkFdSet(CURLM *multi, struct t758_Sockets *sockets,
                                  fd_set *fdset, int evBitmask,
                                  const char *name)
 {
@@ -319,7 +320,7 @@ static CURLMcode t758_checkFdSet(CURLM *curl, struct t758_Sockets *sockets,
   CURLMcode result = CURLM_OK;
   for(i = 0; i < sockets->count; ++i) {
     if(FD_ISSET(sockets->sockets[i], fdset)) {
-      result = t758_saction(curl, sockets->sockets[i], evBitmask, name);
+      result = t758_saction(multi, sockets->sockets[i], evBitmask, name);
       if(result)
         break;
     }
@@ -331,7 +332,8 @@ static CURLcode t758_one(const char *URL, int timer_fail_at,
                          int socket_fail_at)
 {
   CURLcode res = CURLE_OK;
-  CURL *curl = NULL;  CURLM *m = NULL;
+  CURL *curl = NULL;
+  CURLM *multi = NULL;
   struct t758_ReadWriteSockets sockets = {{NULL, 0, 0}, {NULL, 0, 0}};
   int success = 0;
   struct curltime timeout = {0};
@@ -373,28 +375,28 @@ static CURLcode t758_one(const char *URL, int timer_fail_at,
 
   easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, t758_set_ssl_ctx_callback);
 
-  multi_init(m);
+  multi_init(multi);
 
-  multi_setopt(m, CURLMOPT_SOCKETFUNCTION, t758_curlSocketCallback);
-  multi_setopt(m, CURLMOPT_SOCKETDATA, &sockets);
+  multi_setopt(multi, CURLMOPT_SOCKETFUNCTION, t758_curlSocketCallback);
+  multi_setopt(multi, CURLMOPT_SOCKETDATA, &sockets);
 
-  multi_setopt(m, CURLMOPT_TIMERFUNCTION, t758_curlTimerCallback);
-  multi_setopt(m, CURLMOPT_TIMERDATA, &timeout);
+  multi_setopt(multi, CURLMOPT_TIMERFUNCTION, t758_curlTimerCallback);
+  multi_setopt(multi, CURLMOPT_TIMERDATA, &timeout);
 
-  multi_add_handle(m, curl);
+  multi_add_handle(multi, curl);
 
-  if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+  if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
     res = TEST_ERR_MAJOR_BAD;
     goto test_cleanup;
   }
-  while(!t758_checkForCompletion(m, &success)) {
+  while(!t758_checkForCompletion(multi, &success)) {
     fd_set readSet, writeSet;
     curl_socket_t maxFd = 0;
     struct timeval tv = {0};
     tv.tv_sec = 10;
 
     if(t758_ctx.fake_async_cert_verification_pending &&
-        !t758_ctx.fake_async_cert_verification_finished) {
+       !t758_ctx.fake_async_cert_verification_finished) {
       if(sockets.read.count || sockets.write.count) {
         t758_msg("during verification there should be no sockets scheduled");
         res = TEST_ERR_MAJOR_BAD;
@@ -406,13 +408,13 @@ static CURLcode t758_one(const char *URL, int timer_fail_at,
         goto test_cleanup;
       }
       t758_ctx.fake_async_cert_verification_finished = 1;
-      if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+      if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
         t758_msg("spurious retry cert action");
         res = TEST_ERR_MAJOR_BAD;
         goto test_cleanup;
       }
       curl_easy_pause(curl, CURLPAUSE_CONT);
-      if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+      if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
         t758_msg("unblocking transfer after cert verification finished");
         res = TEST_ERR_MAJOR_BAD;
         goto test_cleanup;
@@ -442,12 +444,12 @@ static CURLcode t758_one(const char *URL, int timer_fail_at,
     select_test((int)maxFd, &readSet, &writeSet, NULL, &tv);
 
     /* Check the sockets for reading / writing */
-    if(t758_checkFdSet(m, &sockets.read, &readSet, CURL_CSELECT_IN,
+    if(t758_checkFdSet(multi, &sockets.read, &readSet, CURL_CSELECT_IN,
                        "read")) {
       res = TEST_ERR_MAJOR_BAD;
       goto test_cleanup;
     }
-    if(t758_checkFdSet(m, &sockets.write, &writeSet, CURL_CSELECT_OUT,
+    if(t758_checkFdSet(multi, &sockets.write, &writeSet, CURL_CSELECT_OUT,
                        "write")) {
       res = TEST_ERR_MAJOR_BAD;
       goto test_cleanup;
@@ -456,7 +458,7 @@ static CURLcode t758_one(const char *URL, int timer_fail_at,
     if(timeout.tv_sec != (time_t)-1 &&
        t758_getMicroSecondTimeout(&timeout) == 0) {
       /* Curl's timer has elapsed. */
-      if(t758_saction(m, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
+      if(t758_saction(multi, CURL_SOCKET_TIMEOUT, 0, "timeout")) {
         res = TEST_ERR_BAD_TIMEOUT;
         goto test_cleanup;
       }
@@ -479,9 +481,9 @@ test_cleanup:
 
   /* proper cleanup sequence */
   t758_msg("cleanup");
-  curl_multi_remove_handle(m, curl);
+  curl_multi_remove_handle(multi, curl);
   curl_easy_cleanup(curl);
-  curl_multi_cleanup(m);
+  curl_multi_cleanup(multi);
   curl_global_cleanup();
 
   /* free local memory */

tests/libtest/lib766.c

@@ -42,24 +42,24 @@ static int sockopt_766(void *clientp,
 
 static CURLcode test_lib766(const char *URL)
 {
-  CURL *easy = NULL;
+  CURL *curl = NULL;
   CURLcode res = CURLE_OK;
 
   start_test_timing();
 
   res_global_init(CURL_GLOBAL_ALL);
 
-  easy_init(easy);
-  easy_setopt(easy, CURLOPT_VERBOSE, 1L);
-  easy_setopt(easy, CURLOPT_URL, URL);
-  easy_setopt(easy, CURLOPT_FTPPORT, "-");
-  easy_setopt(easy, CURLOPT_SOCKOPTFUNCTION, sockopt_766);
+  easy_init(curl);
+  easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+  easy_setopt(curl, CURLOPT_URL, URL);
+  easy_setopt(curl, CURLOPT_FTPPORT, "-");
+  easy_setopt(curl, CURLOPT_SOCKOPTFUNCTION, sockopt_766);
 
-  res = curl_easy_perform(easy);
+  res = curl_easy_perform(curl);
 
 test_cleanup:
 
-  curl_easy_cleanup(easy);
+  curl_easy_cleanup(curl);
   curl_global_cleanup();
 
   return res;

tests/libtest/testtrace.c

@@ -81,7 +81,7 @@ void debug_dump(const char *timebuf, const char *text,
   fflush(stream);
 }
 
-int libtest_debug_cb(CURL *handle, curl_infotype type,
+int libtest_debug_cb(CURL *curl, curl_infotype type,
                      char *data, size_t size, void *userp)
 {
   struct libtest_trace_cfg *trace_cfg = userp;
@@ -89,7 +89,7 @@ int libtest_debug_cb(CURL *handle, curl_infotype type,
   char timebuf[20];
   char *timestr;
 
-  (void)handle;
+  (void)curl;
 
   timebuf[0] = '\0';
   timestr = &timebuf[0];
@@ -157,7 +157,7 @@ static void log_line_start(FILE *log, const char *idsbuf, curl_infotype type)
 }
 
 /* callback for CURLOPT_DEBUGFUNCTION (used in client tests) */
-int cli_debug_cb(CURL *handle, curl_infotype type,
+int cli_debug_cb(CURL *curl, curl_infotype type,
                  char *data, size_t size, void *userp)
 {
   FILE *output = stderr;
@@ -166,11 +166,11 @@ int cli_debug_cb(CURL *handle, curl_infotype type,
   char idsbuf[60];
   curl_off_t xfer_id, conn_id;
 
-  (void)handle;
+  (void)curl;
   (void)userp;
 
-  if(!curl_easy_getinfo(handle, CURLINFO_XFER_ID, &xfer_id) && xfer_id >= 0) {
-    if(!curl_easy_getinfo(handle, CURLINFO_CONN_ID, &conn_id) &&
+  if(!curl_easy_getinfo(curl, CURLINFO_XFER_ID, &xfer_id) && xfer_id >= 0) {
+    if(!curl_easy_getinfo(curl, CURLINFO_CONN_ID, &conn_id) &&
        conn_id >= 0) {
       curl_msnprintf(idsbuf, sizeof(idsbuf),
                      "[%" CURL_FORMAT_CURL_OFF_T "-"

tests/libtest/testtrace.h

@@ -36,11 +36,11 @@ struct libtest_trace_cfg {
 
 extern struct libtest_trace_cfg debug_config;
 
-int libtest_debug_cb(CURL *handle, curl_infotype type,
+int libtest_debug_cb(CURL *curl, curl_infotype type,
                      char *data, size_t size, void *userp);
 
 /* callback for CURLOPT_DEBUGFUNCTION (client tests) */
-int cli_debug_cb(CURL *handle, curl_infotype type,
+int cli_debug_cb(CURL *curl, curl_infotype type,
                  char *data, size_t size, void *userp);
 
 #endif /* HEADER_LIBTEST_TESTTRACE_H */