Merge branch 'master' into dev/sigparms1

5 files changed, 67 insertions, 65 deletions

diff --git a/tests/changes.input/06.in b/tests/changes.input/06.in
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/changes.input/06.in
diff --git a/tests/dot b/tests/dot
deleted file mode 100644
index 945c9b4..0000000
--- a/tests/dot
+++ /dev/null
@@ -1 +0,0 @@
-.
\ No newline at end of file
diff --git a/tests/hashtable_test.c b/tests/hashtable_test.c
index 14326ab..0fd18a8 100644
--- a/tests/hashtable_test.c
+++ b/tests/hashtable_test.c
@@ -27,32 +27,32 @@
 #include "hashtable.h"
 
 /* Key type for the hashtable. */
-typedef int key_t;
-void key_init(key_t *k, int i)
+typedef int mykey_t;
+void mykey_init(mykey_t *k, int i)
 {
     /* This is chosen to cause bad key collisions and clustering. */
     *k = (i / 2) * (i / 2);
 }
 
-int key_hash(const key_t *k)
+int mykey_hash(const mykey_t *k)
 {
     return *k;
 }
 
-int key_cmp(key_t *k, const key_t *o)
+int mykey_cmp(mykey_t *k, const mykey_t *o)
 {
     return *k - *o;
 }
 
 /* Entry type for values in hashtable. */
-typedef struct entry {
-    key_t key;                  /* Inherit from key_t. */
+typedef struct myentry {
+    mykey_t key;                  /* Inherit from mykey_t. */
     int value;
-} entry_t;
+} myentry_t;
 
-void entry_init(entry_t *e, int i)
+void myentry_init(myentry_t *e, int i)
 {
-    key_init(&e->key, i);
+    mykey_init(&e->key, i);
     e->value = i;
 }
 
@@ -60,22 +60,22 @@ void entry_init(entry_t *e, int i)
  *
  * This demonstrates using deferred calculation and comparison of the
  * expected value only when the key matches. */
-typedef struct match {
-    key_t key;                  /* Inherit from key_t. */
+typedef struct mymatch {
+    mykey_t key;                  /* Inherit from mykey_t. */
     int value;
     int source;
-} match_t;
+} mymatch_t;
 
-void match_init(match_t *m, int i)
+void mymatch_init(mymatch_t *m, int i)
 {
-    key_init(&m->key, i);
+    mykey_init(&m->key, i);
     m->value = 0;
     m->source = i;
 }
 
-int match_cmp(match_t *m, const entry_t *e)
+int mymatch_cmp(mymatch_t *m, const myentry_t *e)
 {
-    int ans = key_cmp(&m->key, &e->key);
+    int ans = mykey_cmp(&m->key, &e->key);
     /* Calculate and compare value if key matches */
     if (ans == 0) {
         if (m->value != m->source)
@@ -86,77 +86,77 @@ int match_cmp(match_t *m, const entry_t *e)
 }
 
 
-/* Instantiate a simple key_hashtable of keys. */
-#define ENTRY key
+/* Instantiate a simple mykey_hashtable of keys. */
+#define ENTRY mykey
 #include "hashtable.h"
 
-/* Instantiate a fancy hashtable of entrys using a custom match. */
-#define ENTRY entry
-#define KEY key
-#define MATCH match
-#define NAME hashtable
+/* Instantiate a fancy myhashtable of myentrys using a custom match. */
+#define ENTRY myentry
+#define KEY mykey
+#define MATCH mymatch
+#define NAME myhashtable
 #include "hashtable.h"
 
 /* Test driver for hashtable. */
 int main(int argc, char **argv)
 {
-    /* Test key_hashtable instance. */
+    /* Test mykey_hashtable instance. */
     hashtable_t *kt;
     hashtable_iter_t ki;
-    key_t k1, k2;
-
-    key_init(&k1, 1);
-    key_init(&k2, 2);
-    assert((kt = key_hashtable_new(16)) != NULL);
-    assert(key_hashtable_add(kt, &k1) == &k1);
-    assert(key_hashtable_find(kt, &k1) == &k1);
-    assert(key_hashtable_find(kt, &k2) == NULL);
-    assert(key_hashtable_iter(&ki, kt) == &k1);
-    assert(key_hashtable_next(&ki) == NULL);
-
-    /* Test hashtable instance. */
+    mykey_t k1, k2;
+
+    mykey_init(&k1, 1);
+    mykey_init(&k2, 2);
+    assert((kt = mykey_hashtable_new(16)) != NULL);
+    assert(mykey_hashtable_add(kt, &k1) == &k1);
+    assert(mykey_hashtable_find(kt, &k1) == &k1);
+    assert(mykey_hashtable_find(kt, &k2) == NULL);
+    assert(mykey_hashtable_iter(&ki, kt) == &k1);
+    assert(mykey_hashtable_next(&ki) == NULL);
+
+    /* Test myhashtable instance. */
     hashtable_t *t;
-    entry_t entry[256];
-    entry_t e;
-    match_t m;
+    myentry_t entry[256];
+    myentry_t e;
+    mymatch_t m;
     int i;
 
-    entry_init(&e, 0);
+    myentry_init(&e, 0);
     for (i = 0; i < 256; i++)
-        entry_init(&entry[i], i);
+        myentry_init(&entry[i], i);
 
-    /* Test hashtable_new() */
-    t = hashtable_new(256);
+    /* Test myhashtable_new() */
+    t = myhashtable_new(256);
     assert(t->size == 512);
     assert(t->count == 0);
     assert(t->etable != NULL);
     assert(t->ktable != NULL);
 
-    /* Test hashtable_add() */
-    assert(hashtable_add(t, &e) == &e); /* Added duplicated copy. */
-    assert(hashtable_add(t, &entry[0]) == &entry[0]);   /* Added duplicated instance. */
+    /* Test myhashtable_add() */
+    assert(myhashtable_add(t, &e) == &e); /* Added duplicated copy. */
+    assert(myhashtable_add(t, &entry[0]) == &entry[0]);   /* Added duplicated instance. */
     for (i = 0; i < 256; i++)
-        assert(hashtable_add(t, &entry[i]) == &entry[i]);
+        assert(myhashtable_add(t, &entry[i]) == &entry[i]);
     assert(t->count == 258);
 
-    /* Test hashtable_find() */
-    match_init(&m, 0);
-    assert(hashtable_find(t, &m) == &e);        /* Finds first duplicate added. */
-    assert(m.value == m.source);        /* match_cmp() updated m.value. */
+    /* Test myhashtable_find() */
+    mymatch_init(&m, 0);
+    assert(myhashtable_find(t, &m) == &e);        /* Finds first duplicate added. */
+    assert(m.value == m.source);        /* mymatch_cmp() updated m.value. */
     for (i = 1; i < 256; i++) {
-        match_init(&m, i);
-        assert(hashtable_find(t, &m) == &entry[i]);
-        assert(m.value == m.source);    /* match_cmp() updated m.value. */
+        mymatch_init(&m, i);
+        assert(myhashtable_find(t, &m) == &entry[i]);
+        assert(m.value == m.source);    /* mymatch_cmp() updated m.value. */
     }
-    match_init(&m, 256);
-    assert(hashtable_find(t, &m) == NULL);      /* Find missing entry. */
-    assert(m.value == 0);       /* match_cmp() didn't update m.value. */
+    mymatch_init(&m, 256);
+    assert(myhashtable_find(t, &m) == NULL);      /* Find missing myentry. */
+    assert(m.value == 0);       /* mymatch_cmp() didn't update m.value. */
 #ifndef HASHTABLE_NSTATS
     assert(t->find_count == 257);
     assert(t->match_count == 256);
     assert(t->hashcmp_count >= 256);
     assert(t->entrycmp_count >= 256);
-    hashtable_stats_init(t);
+    myhashtable_stats_init(t);
     assert(t->find_count == 0);
     assert(t->match_count == 0);
     assert(t->hashcmp_count == 0);
@@ -164,15 +164,15 @@ int main(int argc, char **argv)
 #endif
 
     /* Test hashtable iterators */
-    entry_t *p;
+    myentry_t *p;
     hashtable_iter_t iter;
     int count = 0;
-    for (p = hashtable_iter(&iter, t); p != NULL; p = hashtable_next(&iter)) {
+    for (p = myhashtable_iter(&iter, t); p != NULL; p = myhashtable_next(&iter)) {
         assert(p == &e || (&entry[0] <= p && p <= &entry[255]));
         count++;
     }
     assert(count == 258);
-    hashtable_free(t);
+    myhashtable_free(t);
 
     return 0;
 }
diff --git a/tests/largefile.test b/tests/largefile.test
index 2bb0b49..4d062d4 100755
--- a/tests/largefile.test
+++ b/tests/largefile.test
@@ -39,6 +39,9 @@ blocks=${2:-64K}
 datadir=${3:-$tmpdir}
 echo "DATADIR $datadir"
 
+# Use $4 to optionally specify a block size to use.
+blocksize=${4:-1024}
+
 old="$datadir/old.$blocks"
 new="$datadir/new.$blocks"
 sig="$datadir/sig.$blocks"
@@ -54,8 +57,8 @@ if [ ! -f "$old" ]; then
    dd bs=$blocks count=256 skip=640 if="$old" >>"$new"
 fi
 
-run_test time $bindir/rdiff $debug -f -b 1024 -S 8 -s signature $old $sig
-run_test time $bindir/rdiff $debug -f -s -I 32768 -O 32768 delta $sig $new $delta
+run_test time $bindir/rdiff $debug -f -s -b $blocksize -S 8 signature $old $sig
+run_test time $bindir/rdiff $debug -f -s delta $sig $new $delta
 run_test time $bindir/rdiff $debug -f -s patch $old $delta $out
 check_compare $new $out "large files"
 true
diff --git a/tests/testcommon.sh b/tests/testcommon.sh
index bd949e1..e59b1ce 100644
--- a/tests/testcommon.sh
+++ b/tests/testcommon.sh
@@ -51,7 +51,7 @@ delta_instr="
 10,1:8,4:6,8:4,10:2,12
 0,10000:0,10000:0,10000
 "
-bufsizes='4096 1 2 3 7 15 100 10000 200000'
+bufsizes='0 1 2 3 7 15 100 10000 200000'
 
 run_test () {
     if :|| test -n "$VERBOSE"