third-party libs

third-party/curl-7.21.4/tests/unit/.gitignore

@@ -0,0 +1 @@
+unit13[0-9][0-9]

third-party/curl-7.21.4/tests/unit/Makefile.am

@@ -0,0 +1,77 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+AUTOMAKE_OPTIONS = foreign nostdinc
+
+# Specify our include paths here, and do it relative to $(top_srcdir) and
+# $(top_builddir), to ensure that these paths which belong to the library
+# being currently built and tested are searched before the library which
+# might possibly already be installed in the system.
+#
+# $(top_builddir)/include/curl for generated curlbuild.h included from curl.h
+# $(top_builddir)/include for generated curlbuild.h included from lib/setup.h
+# $(top_srcdir)/include is for libcurl's external include files
+# $(top_builddir)/lib is for libcurl's generated lib/curl_config.h file
+# $(top_srcdir)/lib is for libcurl's lib/setup.h and other "borrowed" files
+# $(top_builddir)/ares is for in-tree c-ares's generated ares_build.h file
+# $(top_srcdir)/ares is for in-tree c-ares's external include files
+
+if USE_EMBEDDED_ARES
+INCLUDES = -I$(top_builddir)/include/curl \
+           -I$(top_builddir)/include      \
+           -I$(top_srcdir)/include        \
+           -I$(top_builddir)/lib          \
+           -I$(top_srcdir)/lib            \
+	   -I$(top_srcdir)/tests/libtest  \
+           -I$(top_builddir)/ares         \
+           -I$(top_srcdir)/ares
+else
+INCLUDES = -I$(top_builddir)/include/curl \
+           -I$(top_builddir)/include      \
+           -I$(top_srcdir)/include        \
+           -I$(top_builddir)/lib          \
+           -I$(top_srcdir)/lib 		  \
+	   -I$(top_srcdir)/tests/libtest
+endif
+
+if CURLDEBUG
+
+EXTRA_DIST = Makefile.inc
+
+LDADD = $(top_builddir)/tests/libtest/first.o $(top_builddir)/lib/libcurlu.la \
+	@CURL_LIBS@
+DEPENDENCIES = $(top_builddir)/lib/libcurlu.la
+
+# Makefile.inc provides the source defines (TESTUTIL, SUPPORTFILES,
+# noinst_PROGRAMS, lib*_SOURCES, and lib*_CFLAGS)
+include Makefile.inc
+
+if NO_UNDEFINED
+# The -no-undefined flag is crucial to build fine on some platforms
+UNDEF = -no-undefined
+endif
+
+
+else
+# do nothing if debug was not enabled
+all:
+
+endif

third-party/curl-7.21.4/tests/unit/Makefile.inc

@@ -0,0 +1,12 @@
+# these files are used in every single unit test program
+
+UNITFILES = curlcheck.h
+
+# These are all unit test programs
+noinst_PROGRAMS = unit1300 unit1301 unit1302 unit1303 unit1304
+
+unit1300_SOURCES = unit1300.c $(UNITFILES)
+unit1301_SOURCES = unit1301.c $(UNITFILES)
+unit1302_SOURCES = unit1302.c $(UNITFILES)
+unit1303_SOURCES = unit1303.c $(UNITFILES)
+unit1304_SOURCES = unit1304.c $(UNITFILES)

third-party/curl-7.21.4/tests/unit/README

@@ -0,0 +1,73 @@
+Unit tests
+==========
+
+The goal is to add tests for *ALL* functions in libcurl. If functions are too
+big and complicated, we should split them into smaller and testable ones.
+
+Build Unit Tests
+================
+
+'./configure --enable-debug' is required for the unit tests to build. To
+enable unit tests, there will be a separate static libcurl built that will be
+used exclusively for linking unit test programs. Just build everything as
+normal, and then you can run the unit test cases as well.
+
+Run Unit Tests
+==============
+
+Unit tests are run as part of the regular test suite. If you have built
+everything to run unit tests, to can do 'make test' at the root level. Or you
+can 'cd tests' and then invoke individual unit tests with ./runtests.pl NNNN
+where NNNN is the specific test number.
+
+Debug Unit Tests
+================
+
+If a specific test fails you will get told. The test case then has output left
+in the log/ subdirectory, but most importantly you can re-run the test again
+using gdb by doing ./runtests.pl -g NNNN. That is, add a -g to make it start
+up gdb and run the same case using that.
+
+Write Unit Tests
+================
+
+We put tests that focus on an area or a specific function into a single C
+source file. The source file should be named 'unitNNNN.c' where NNNN is a
+number that starts with 1300 and you can pick the next free number.
+
+You also need a separate file called tests/data/testNNNN (using the same
+number) that describes your test case. See the test1300 file for inspiration
+and the tests/FILEFORMAT documentation.
+
+For the actual C file, here's a very simple example:
+
+----------------------- start -------------------------------
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "a libcurl header.h" /* from the lib dir */
+#include "curlcheck.h"
+
+static void unit_setup( void )
+{
+  /* whatever you want done first */
+}
+
+static void unit_stop( void )
+{
+  /* done before shutting down and exiting */
+}
+
+UNITTEST_START
+
+  /* here you start doing things and checking that the results are good */
+
+  fail_unless( size == 0 , "initial size should be zero" );
+  fail_if( head == NULL , "head should not be initiated to NULL" );
+ 
+  /* you end the test code like this: */
+ 
+UNITTEST_STOP
+
+----------------------- end -------------------------------

third-party/curl-7.21.4/tests/unit/curlcheck.h

@@ -0,0 +1,58 @@
+/*****************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ */
+
+#include "test.h"
+
+#define fail_if(expr, msg)                              \
+  if(expr) {                                            \
+    fprintf(stderr, "%s:%d Assertion '%s' met: %s\n" ,  \
+            __FILE__, __LINE__, #expr, msg);            \
+    unitfail++;                                         \
+  }
+
+#define fail_unless(expr, msg)                           \
+  if(!(expr)) {                                          \
+    fprintf(stderr, "%s:%d Assertion '%s' failed: %s\n", \
+            __FILE__, __LINE__, #expr, msg);             \
+    unitfail++;                                          \
+  }
+
+#define verify_memory(dynamic, check, len)                              \
+  if(dynamic && memcmp(dynamic, check, len)) {                          \
+    fprintf(stderr, "%s:%d The dynamic string didn't match '%s'\n",     \
+            __FILE__, __LINE__, check);                                 \
+    unitfail++;                                                         \
+  }
+
+/* fail() is for when the test case figured out by itself that a check
+   proved a failure */
+#define fail(msg) do {                                                 \
+    fprintf(stderr, "%s:%d test failed: '%s'\n",                       \
+            __FILE__, __LINE__, msg);                                  \
+    unitfail++;                                                        \
+  } while(0)
+
+
+
+extern int unitfail;
+
+#define UNITTEST_START                          \
+  int test(char *unused)                        \
+  {                                             \
+  (void)unused;                                 \
+  if (unit_setup()) {                           \
+    fail("unit_setup() failure");               \
+  } else {
+
+#define UNITTEST_STOP                           \
+    unit_stop();                                \
+  }                                             \
+  return unitfail;                              \
+  }
+

third-party/curl-7.21.4/tests/unit/unit1300.c

@@ -0,0 +1,196 @@
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "llist.h"
+#include "curlcheck.h"
+
+struct curl_llist *llist;
+
+static void test_curl_llist_dtor(void *key, void *value)
+{
+  /* used by the llist API, does nothing here */
+  (void)key;
+  (void)value;
+}
+
+static CURLcode unit_setup(void)
+{
+  llist = Curl_llist_alloc(test_curl_llist_dtor);
+  if (!llist)
+    return CURLE_OUT_OF_MEMORY;
+  return CURLE_OK;
+}
+
+static void unit_stop(void)
+{
+  Curl_llist_destroy(llist, NULL);
+}
+
+UNITTEST_START
+  int unusedData_case1 = 1;
+  int unusedData_case2 = 2;
+  int unusedData_case3 = 3;
+  struct curl_llist_element *head;
+  struct curl_llist_element *element_next;
+  struct curl_llist_element *element_prev;
+  struct curl_llist_element *to_remove;
+  size_t llist_size = Curl_llist_count(llist);
+  int curlErrCode = 0;
+
+  fail_unless(llist->size == 0, "list initial size should be zero");
+  fail_unless(llist->head == NULL, "list head should initiate to NULL");
+  fail_unless(llist->tail == NULL, "list tail should intiate to NULL");
+  fail_unless(llist->dtor == test_curl_llist_dtor,
+               "list dtor shold initiate to test_curl_llist_dtor");
+
+  /**
+   * testing Curl_llist_insert_next
+   * case 1:
+   * list is empty
+   * @assumptions:
+   * 1: list size will be 1
+   * 2: list head will hold the data "unusedData_case1"
+   * 3: list tail will be the same as list head
+   */
+
+  curlErrCode = Curl_llist_insert_next(llist, llist->head, &unusedData_case1);
+  if(curlErrCode == 1) {
+    fail_unless(Curl_llist_count(llist) == 1,
+                 "List size should be 1 after adding a new element");
+    /*test that the list head data holds my unusedData */
+    fail_unless(llist->head->ptr == &unusedData_case1,
+                 "List size should be 1 after adding a new element");
+    /*same goes for the list tail */
+    fail_unless(llist->tail == llist->head,
+                 "List size should be 1 after adding a new element");
+
+    /**
+     * testing Curl_llist_insert_next
+     * case 2:
+     * list has 1 element, adding one element after the head
+     * @assumptions:
+     * 1: the element next to head should be our newly created element
+     * 2: the list tail should be our newly created element
+     */
+
+    curlErrCode = Curl_llist_insert_next(llist, llist->head,
+                                         &unusedData_case3);
+    if(curlErrCode == 1) {
+      fail_unless(llist->head->next->ptr == &unusedData_case3,
+                  "the node next to head is not getting set correctly");
+      fail_unless(llist->tail->ptr == &unusedData_case3,
+                  "the list tail is not getting set correctly");
+    }
+    else {
+      printf("skipping Curl_llist_insert_next as a non "
+             "success error code was returned\n");
+    }
+
+    /**
+     * testing Curl_llist_insert_next
+     * case 3:
+     * list has >1 element, adding one element after "NULL"
+     * @assumptions:
+     * 1: the element next to head should be our newly created element
+     * 2: the list tail should different from newly created element
+     */
+
+    curlErrCode = Curl_llist_insert_next(llist, llist->head,
+                                         &unusedData_case2);
+    if(curlErrCode == 1) {
+      fail_unless(llist->head->next->ptr == &unusedData_case2,
+                  "the node next to head is not getting set correctly");
+      /* better safe than sorry, check that the tail isn't corrupted */
+      fail_unless(llist->tail->ptr != &unusedData_case2,
+                  "the list tail is not getting set correctly");
+    }
+    else {
+      printf("skipping Curl_llist_insert_next as a non "
+             "success error code was returned\n");
+    }
+
+  }
+  else {
+    printf("skipping Curl_llist_insert_next as a non "
+           "success error code was returned\n");
+  }
+
+  /* unit tests for Curl_llist_remove */
+
+  /**
+   * case 1:
+   * list has >1 element, removing head
+   * @assumptions:
+   * 1: list size will be decremented by one
+   * 2: head will be the head->next
+   * 3: "new" head's previous will be NULL
+   */
+
+  head=llist->head;
+  element_next = head->next;
+  llist_size = Curl_llist_count(llist);
+
+  Curl_llist_remove(llist, llist->head, NULL);
+
+  fail_unless(Curl_llist_count(llist) ==  (llist_size-1),
+               "llist size not decremented as expected");
+  fail_unless(llist->head == element_next,
+               "llist new head not modified properly");
+  fail_unless(llist->head->prev == NULL,
+              "new head previous not set to null");
+
+  /**
+   * case 2:
+   * removing non head element, with list having >=2 elements
+   * @setup:
+   * 1: insert another element to the list to make element >=2
+   * @assumptions:
+   * 1: list size will be decremented by one ; tested
+   * 2: element->previous->next will be element->next
+   * 3: element->next->previous will be element->previous
+   */
+  Curl_llist_insert_next(llist, llist->head, &unusedData_case3);
+  llist_size = Curl_llist_count(llist);
+  to_remove = llist->head->next;
+  element_next = to_remove->next;
+  element_prev = to_remove->prev;
+  Curl_llist_remove(llist, to_remove, NULL);
+  fail_unless(element_prev->next == element_next,
+              "element previous->next is not being adjusted");
+  fail_unless(element_next->prev == element_prev,
+              "element next->previous is not being adjusted");
+
+  /**
+   * case 3:
+   * removing the tail with list having >=1 element
+   * @assumptions
+   * 1: list size will be decremented by one ;tested
+   * 2: element->previous->next will be element->next ;tested
+   * 3: element->next->previous will be element->previous ;tested
+   * 4: list->tail will be tail->previous
+   */
+
+  to_remove = llist->tail;
+  element_prev = to_remove->prev;
+  Curl_llist_remove(llist, to_remove, NULL);
+  fail_unless(llist->tail == element_prev,
+              "llist tail is not being adjusted when removing tail");
+
+  /**
+   * case 4:
+   * removing head with list having 1 element
+   * @assumptions:
+   * 1: list size will be decremented by one ;tested
+   * 2: list head will be null
+   * 3: list tail will be null
+   */
+
+  to_remove = llist->head;
+  Curl_llist_remove(llist, to_remove, NULL);
+  fail_unless(llist->head == NULL,
+              "llist head is not NULL while the llist is empty");
+  fail_unless(llist->tail == NULL,
+              "llist tail is not NULL while the llist is empty");
+
+UNITTEST_STOP

third-party/curl-7.21.4/tests/unit/unit1301.c

@@ -0,0 +1,36 @@
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "strequal.h"
+#include "curlcheck.h"
+
+static CURLcode unit_setup( void ) {return CURLE_OK;}
+static void unit_stop( void ) {}
+
+UNITTEST_START
+
+int rc;
+
+rc = curl_strequal("iii", "III");
+fail_unless( rc != 0 , "return code should be zero" );
+
+rc = curl_strequal("iiia", "III");
+fail_unless( rc == 0 , "return code should be zero" );
+
+rc = curl_strequal("iii", "IIIa");
+fail_unless( rc == 0 , "return code should be zero" );
+
+rc = curl_strequal("iiiA", "IIIa");
+fail_unless( rc != 0 , "return code should be non-zero" );
+
+rc = curl_strnequal("iii", "III", 3);
+fail_unless( rc != 0 , "return code should be non-zero" );
+
+rc = curl_strnequal("iiiABC", "IIIcba", 3);
+fail_unless( rc != 0 , "return code should be non-zero" );
+
+rc = curl_strnequal("ii", "II", 3);
+fail_unless( rc != 0 , "return code should be non-zero" );
+
+UNITTEST_STOP

third-party/curl-7.21.4/tests/unit/unit1302.c

@@ -0,0 +1,89 @@
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "urldata.h"
+#include "url.h" /* for Curl_safefree */
+#include "curl_base64.h"
+#include "curlcheck.h"
+#include "memdebug.h" /* LAST include file */
+
+static struct SessionHandle *data;
+
+static CURLcode unit_setup( void )
+{
+  data = curl_easy_init();
+  if (!data)
+    return CURLE_OUT_OF_MEMORY;
+  return CURLE_OK;
+}
+
+static void unit_stop( void )
+{
+  curl_easy_cleanup(data);
+}
+
+UNITTEST_START
+
+char *output;
+unsigned char *decoded;
+size_t rc;
+
+rc = Curl_base64_encode(data, "i", 1, &output);
+fail_unless( rc == 4 , "return code should be 4" );
+verify_memory( output, "aQ==", 4);
+Curl_safefree(output);
+
+rc = Curl_base64_encode(data, "ii", 2, &output);
+fail_unless( rc == 4 , "return code should be 4" );
+verify_memory( output, "aWk=", 4);
+Curl_safefree(output);
+
+rc = Curl_base64_encode(data, "iii", 3, &output);
+fail_unless( rc == 4 , "return code should be 4" );
+verify_memory( output, "aWlp", 4);
+Curl_safefree(output);
+
+rc = Curl_base64_encode(data, "iiii", 4, &output);
+fail_unless( rc == 8 , "return code should be 8" );
+verify_memory( output, "aWlpaQ==", 8);
+Curl_safefree(output);
+
+/* 0 length makes it do strlen() */
+rc = Curl_base64_encode(data, "iiii", 0, &output);
+fail_unless( rc == 8 , "return code should be 8" );
+verify_memory( output, "aWlpaQ==", 8);
+Curl_safefree(output);
+
+rc = Curl_base64_decode("aWlpaQ==", &decoded);
+fail_unless(rc == 4, "return code should be 4");
+verify_memory(decoded, "iiii", 4);
+Curl_safefree(decoded);
+
+rc = Curl_base64_decode("aWlp", &decoded);
+fail_unless(rc == 3, "return code should be 3");
+verify_memory(decoded, "iii", 3);
+Curl_safefree(decoded);
+
+rc = Curl_base64_decode("aWk=", &decoded);
+fail_unless(rc == 2, "return code should be 2");
+verify_memory(decoded, "ii", 2);
+Curl_safefree(decoded);
+
+rc = Curl_base64_decode("aQ==", &decoded);
+fail_unless(rc == 1, "return code should be 1");
+verify_memory(decoded, "i", 2);
+Curl_safefree(decoded);
+
+/* this is an illegal input */
+decoded = NULL;
+rc = Curl_base64_decode("aQ", &decoded);
+fail_unless(rc == 0, "return code should be 0");
+fail_if(decoded, "returned pointer should be NULL");
+
+/* this is garbage input that libcurl decodes as far as possible */
+rc = Curl_base64_decode("a\x1f==", &decoded);
+fail_unless(rc == 1, "return code should be 1");
+Curl_safefree(decoded);
+
+UNITTEST_STOP

third-party/curl-7.21.4/tests/unit/unit1303.c

@@ -0,0 +1,126 @@
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "urldata.h"
+#include "connect.h"
+#include "curlcheck.h"
+#include "memdebug.h" /* LAST include file */
+
+static struct SessionHandle *data;
+
+static CURLcode unit_setup( void )
+{
+  data = curl_easy_init();
+  if (!data)
+    return CURLE_OUT_OF_MEMORY;
+  return CURLE_OK;
+}
+
+static void unit_stop( void )
+{
+  curl_easy_cleanup(data);
+}
+
+/* BASE is just a define to make us fool around with decently large number so
+   that we aren't zero-based */
+#define BASE 1000000
+
+/* macro to set the pretended current time */
+#define NOW(x,y) now.tv_sec = x; now.tv_usec = y
+/* macro to set the millisecond based timeouts to use */
+#define TIMEOUTS(x,y) data->set.timeout = x; data->set.connecttimeout = y
+
+/*
+ * To test:
+ *
+ * 00/10/01/11 timeouts set
+ * 0/1         during connect
+ * T           various values on the timeouts
+ * N           various values of now
+ */
+
+struct timetest {
+  int now_s;
+  int now_us;
+  int timeout_ms;
+  int connecttimeout_ms;
+  int connecting;
+  long result;
+  const char *comment;
+};
+
+UNITTEST_START
+
+struct timeval now;
+long timeout;
+unsigned int i;
+
+const struct timetest run[] = {
+  /* both timeouts set, not connecting */
+  {BASE + 4, 0,      10000, 8000, FALSE, 6000, "6 seconds should be left"},
+  {BASE + 4, 990000, 10000, 8000, FALSE, 5010, "5010 ms should be left"},
+  {BASE + 10, 0,     10000, 8000, FALSE, -1,   "timeout is -1, expired"},
+  {BASE + 12, 0,     10000, 8000, FALSE, -2000, "-2000, overdue 2 seconds"},
+
+  /* both timeouts set, connecting */
+  {BASE + 4, 0,      10000, 8000, TRUE, 4000, "4 seconds should be left"},
+  {BASE + 4, 990000, 10000, 8000, TRUE, 3010, "3010 ms should be left"},
+  {BASE + 8, 0,      10000, 8000, TRUE, -1,   "timeout is -1, expired"},
+  {BASE + 10, 0,     10000, 8000, TRUE, -2000, "-2000, overdue 2 seconds"},
+
+  /* no connect timeout set, not connecting */
+  {BASE + 4, 0,      10000, 0, FALSE, 6000, "6 seconds should be left"},
+  {BASE + 4, 990000, 10000, 0, FALSE, 5010, "5010 ms should be left"},
+  {BASE + 10, 0,     10000, 0, FALSE, -1,   "timeout is -1, expired"},
+  {BASE + 12, 0,     10000, 0, FALSE, -2000, "-2000, overdue 2 seconds"},
+
+  /* no connect timeout set, connecting */
+  {BASE + 4, 0,      10000, 0, FALSE, 6000, "6 seconds should be left"},
+  {BASE + 4, 990000, 10000, 0, FALSE, 5010, "5010 ms should be left"},
+  {BASE + 10, 0,     10000, 0, FALSE, -1,   "timeout is -1, expired"},
+  {BASE + 12, 0,     10000, 0, FALSE, -2000, "-2000, overdue 2 seconds"},
+
+  /* only connect timeout set, not connecting */
+  {BASE + 4, 0,      0, 10000, FALSE, 0, "no timeout active"},
+  {BASE + 4, 990000, 0, 10000, FALSE, 0, "no timeout active"},
+  {BASE + 10, 0,     0, 10000, FALSE, 0, "no timeout active"},
+  {BASE + 12, 0,     0, 10000, FALSE, 0, "no timeout active"},
+
+  /* only connect timeout set, connecting */
+  {BASE + 4, 0,      0, 10000, TRUE, 6000, "6 seconds should be left"},
+  {BASE + 4, 990000, 0, 10000, TRUE, 5010, "5010 ms should be left"},
+  {BASE + 10, 0,     0, 10000, TRUE, -1,   "timeout is -1, expired"},
+  {BASE + 12, 0,     0, 10000, TRUE, -2000, "-2000, overdue 2 seconds"},
+
+  /* no timeout set, not connecting */
+  {BASE + 4, 0,      0, 0, FALSE, 0, "no timeout active"},
+  {BASE + 4, 990000, 0, 0, FALSE, 0, "no timeout active"},
+  {BASE + 10, 0,     0, 0, FALSE, 0, "no timeout active"},
+  {BASE + 12, 0,     0, 0, FALSE, 0, "no timeout active"},
+
+  /* no timeout set, connecting */
+  {BASE + 4, 0,      0, 0, TRUE, 296000, "no timeout active"},
+  {BASE + 4, 990000, 0, 0, TRUE, 295010, "no timeout active"},
+  {BASE + 10, 0,     0, 0, TRUE, 290000, "no timeout active"},
+  {BASE + 12, 0,     0, 0, TRUE, 288000, "no timeout active"},
+
+  /* both timeouts set, connecting, connect timeout the longer one */
+  {BASE + 4, 0,      10000, 12000, TRUE, 6000, "6 seconds should be left"},
+
+};
+
+/* this is the pretended start time of the transfer */
+data->progress.t_startsingle.tv_sec = BASE;
+data->progress.t_startsingle.tv_usec = 0;
+
+for(i=0; i < sizeof(run)/sizeof(run[0]); i++) {
+  NOW(run[i].now_s, run[i].now_us);
+  TIMEOUTS(run[i].timeout_ms, run[i].connecttimeout_ms);
+  timeout =  Curl_timeleft(data, &now, run[i].connecting);
+  if(timeout != run[i].result)
+    fail(run[i].comment);
+}
+
+
+UNITTEST_STOP

third-party/curl-7.21.4/tests/unit/unit1304.c

@@ -0,0 +1,124 @@
+#include <stdlib.h>
+#include "curl_config.h"
+#include "setup.h"
+
+#include "netrc.h"
+#include "curlcheck.h"
+
+char login[LOGINSIZE];
+char password[PASSWORDSIZE];
+char filename[64];
+
+static CURLcode unit_setup(void)
+{
+  password[0] = 0;
+  login[0] = 0;
+  return CURLE_OK;
+}
+
+static void unit_stop(void)
+{
+}
+
+UNITTEST_START
+  int result;
+
+  static const char* filename1 = "log/netrc";
+  memcpy(filename, filename1, strlen(filename1));
+
+  /*
+   * Test a non existent host in our netrc file.
+   */
+  result = Curl_parsenetrc("test.example.com", login, password, filename);
+  fail_unless(result == 1, "Host not found should return 1");
+  fail_unless(password[0] == 0, "password should not have been changed");
+  fail_unless(login[0] == 0, "login should not have been changed");
+
+  /*
+   * Test a non existent login in our netrc file.
+   */
+  memcpy(login, "me", 2);
+  result = Curl_parsenetrc("example.com", login, password, filename);
+  fail_unless(result == 0, "Host should be found");
+  fail_unless(password[0] == 0, "password should not have been changed");
+  fail_unless(strncmp(login, "me", 2) == 0, "login should not have been changed");
+
+  /*
+   * Test a non existent login and host in our netrc file.
+   */
+  memcpy(login, "me", 2);
+  result = Curl_parsenetrc("test.example.com", login, password, filename);
+  fail_unless(result == 1, "Host should be found");
+  fail_unless(password[0] == 0, "password should not have been changed");
+  fail_unless(strncmp(login, "me", 2) == 0, "login should not have been changed");
+
+  /*
+   * Test a non existent login (substring of an existing one) in our
+   * netrc file.
+   */
+  memcpy(login, "admi", 4);
+  result = Curl_parsenetrc("example.com", login, password, filename);
+  fail_unless(result == 0, "Host should be found");
+  fail_unless(password[0] == 0, "password should not have been changed");
+  fail_unless(strncmp(login, "admi", 4) == 0, "login should not have been changed");
+
+  /*
+   * Test a non existent login (superstring of an existing one)
+   * in our netrc file.
+   */
+  memcpy(login, "adminn", 6);
+  result = Curl_parsenetrc("example.com", login, password, filename);
+  fail_unless(result == 0, "Host should be found");
+  fail_unless(password[0] == 0, "password should not have been changed");
+  fail_unless(strncmp(login, "adminn", 6) == 0, "login should not have been changed");
+
+  /*
+   * Test for the first existing host in our netrc file
+   * with login[0] = 0.
+   */
+  login[0] = 0;
+  result = Curl_parsenetrc("example.com", login, password, filename);
+  fail_unless(result == 0, "Host should have been found");
+  fail_unless(strncmp(password, "passwd", 6) == 0,
+              "password should be 'passwd'");
+  fail_unless(strncmp(login, "admin", 5) == 0, "login should be 'admin'");
+
+  /*
+   * Test for the first existing host in our netrc file
+   * with login[0] != 0.
+   */
+  password[0] = 0;
+  result = Curl_parsenetrc("example.com", login, password, filename);
+  fail_unless(result == 0, "Host should have been found");
+  fail_unless(strncmp(password, "passwd", 6) == 0,
+              "password should be 'passwd'");
+  fail_unless(strncmp(login, "admin", 5) == 0, "login should be 'admin'");
+
+  /*
+   * Test for the second existing host in our netrc file
+   * with login[0] = 0.
+   */
+  password[0] = 0;
+  login[0] = 0;
+  result = Curl_parsenetrc("curl.example.com", login, password, filename);
+  fail_unless(result == 0, "Host should have been found");
+  fail_unless(strncmp(password, "none", 4) == 0,
+              "password should be 'none'");
+  fail_unless(strncmp(login, "none", 4) == 0, "login should be 'none'");
+
+  /*
+   * Test for the second existing host in our netrc file
+   * with login[0] != 0.
+   */
+  password[0] = 0;
+  result = Curl_parsenetrc("curl.example.com", login, password, filename);
+  fail_unless(result == 0, "Host should have been found");
+  fail_unless(strncmp(password, "none", 4) == 0,
+              "password should be 'none'");
+  fail_unless(strncmp(login, "none", 4) == 0, "login should be 'none'");
+
+  /* TODO:
+   * Test over the size limit password / login!
+   * Test files with a bad format
+   */
+UNITTEST_STOP