6 files changed, 96 insertions, 44 deletions

diff --git a/xdelta3/testing/regtest.cc b/xdelta3/testing/regtest.cc
index f64111e..3b4d4c6 100644
--- a/xdelta3/testing/regtest.cc
+++ b/xdelta3/testing/regtest.cc
@@ -68,8 +68,8 @@ void InMemoryEncodeDecode(FileSpec &source_file, FileSpec &target_file) {
       ret = xd3_decode_input(&decode_stream);
     }
 
-    DP(RINT "%s = %s\n", encoding ? "encoding" : "decoding",
-       xd3_strerror(ret));
+    //DP(RINT "%s = %s\n", encoding ? "encoding" : "decoding",
+    //   xd3_strerror(ret));
 
     switch (ret) {
     case XD3_OUTPUT:
@@ -117,7 +117,7 @@ void InMemoryEncodeDecode(FileSpec &source_file, FileSpec &target_file) {
         encoding = false;
       } else {
         CHECK_EQ(0, CmpDifferentBlockBytes(decoded_block, target_block));
-        DP(RINT "verified block %"Q"u\n", target_iterator.Blkno());
+        //DP(RINT "verified block %"Q"u\n", target_iterator.Blkno());
         decoded_block.Reset();
         encoding = true;
       }
@@ -236,23 +236,18 @@ void TestFirstByte() {
   spec0.GenerateFixedSize(Constants::BLOCK_SIZE + 1);
   spec0.ModifyTo<Modify1stByte>(&spec1);
   CHECK_EQ(1, CmpDifferentBytes(spec0, spec1));
-}
-
-void TestBasicEncodeDecode() {
-  MTRandom rand;
-  FileSpec spec0(&rand);
-  FileSpec spec1(&rand);
-  spec0.GenerateFixedSize(1024);
-  spec0.ModifyTo<Modify1stByte>(&spec1);
-  InMemoryEncodeDecode(spec0, spec1);
 
-  spec0.GenerateFixedSize(Constants::BLOCK_SIZE);
-  spec0.ModifyTo<Modify1stByte>(&spec1);
-  InMemoryEncodeDecode(spec0, spec1);
+  SizeIterator<size_t, SmallSizes> si(&rand, 20);
 
-  spec0.GenerateFixedSize(Constants::BLOCK_SIZE * 2);
-  spec0.ModifyTo<Modify1stByte>(&spec1);
-  InMemoryEncodeDecode(spec0, spec1);
+  for (; !si.Done(); si.Next()) {
+    size_t size = si.Get();
+    if (size == 0) {
+      continue;
+    }
+    spec0.GenerateFixedSize(size);
+    spec0.ModifyTo<Modify1stByte>(&spec1);
+    InMemoryEncodeDecode(spec0, spec1);
+  }
 }
 
 int main(int argc, char **argv) {
@@ -260,7 +255,6 @@ int main(int argc, char **argv) {
   TEST(TestRandomNumbers);
   TEST(TestRandomFile);
   TEST(TestFirstByte);
-  TEST(TestBasicEncodeDecode);
   return 0;
 }
 
diff --git a/xdelta3/testing/sizes.h b/xdelta3/testing/sizes.h
new file mode 100644
index 0000000..8913baa
--- /dev/null
+++ b/xdelta3/testing/sizes.h
@@ -0,0 +1,55 @@
+// -*- Mode: C++ -*-
+namespace regtest {
+
+template <typename T, typename U>
+class SizeIterator {
+ public:
+  SizeIterator(MTRandom *rand, size_t howmany)
+    : rand_(rand),
+      count_(0),
+      fixed_(U::sizes),
+      fixed_size_(SIZEOF_ARRAY(U::sizes)),
+      howmany_(howmany) { }
+
+  T Get() {
+    if (count_ < fixed_size_) {
+      return fixed_[count_];
+    }
+    return rand_->Rand<T>() % U::max_value;
+  }
+
+  bool Done() {
+    return count_ >= howmany_;
+  }
+
+  void Next() {
+    count_++;
+  }
+
+ private:
+  MTRandom *rand_;
+  size_t count_;
+  T* fixed_;
+  size_t fixed_size_;
+  size_t howmany_;
+};
+
+class SmallSizes {
+public:
+  static size_t sizes[];
+  static size_t max_value;
+};
+
+size_t SmallSizes::sizes[] = {
+  0, 1, 1024, 3333, 
+  Constants::BLOCK_SIZE - 3333,
+  Constants::BLOCK_SIZE,
+  Constants::BLOCK_SIZE + 3333,
+  2 * Constants::BLOCK_SIZE - 3333,
+  2 * Constants::BLOCK_SIZE,
+  2 * Constants::BLOCK_SIZE + 3333,
+};
+
+size_t SmallSizes::max_value = Constants::BLOCK_SIZE * 3;
+
+}  // namespace regtest
diff --git a/xdelta3/testing/test.h b/xdelta3/testing/test.h
index 74767fd..4d2dc8a 100644
--- a/xdelta3/testing/test.h
+++ b/xdelta3/testing/test.h
@@ -59,3 +59,7 @@ using regtest::Modify1stByte;
 
 #include "cmp.h"
 using regtest::CmpDifferentBytes;
+
+#include "sizes.h"
+using regtest::SizeIterator;
+using regtest::SmallSizes;
diff --git a/xdelta3/xdelta3-test.h b/xdelta3/xdelta3-test.h
index 02c440a..c34aa3f 100644
--- a/xdelta3/xdelta3-test.h
+++ b/xdelta3/xdelta3-test.h
@@ -31,7 +31,7 @@
 
 struct mtrand_ {
   int mt_index;
-  usize_t mt_buffer[MT_LEN];
+  uint32_t mt_buffer[MT_LEN];
 };
 
 typedef struct mtrand_ mtrand;
@@ -46,13 +46,13 @@ static void mt_init (mtrand *mt, int seed) {
   mt->mt_index = 0;
 }
 
-static usize_t mt_random (mtrand *mt) {
-  usize_t * b = mt->mt_buffer;
+static uint32_t mt_random (mtrand *mt) {
+  uint32_t * b = mt->mt_buffer;
   int idx = mt->mt_index;
-  usize_t s;
+  uint32_t s;
   int i;
         
-  if (idx == MT_LEN*sizeof(usize_t))
+  if (idx == MT_LEN*sizeof(uint32_t))
     {
       idx = 0;
       i = 0;
@@ -68,14 +68,25 @@ static usize_t mt_random (mtrand *mt) {
       s = TWIST(b, MT_LEN-1, 0);
       b[MT_LEN-1] = b[MT_IA-1] ^ (s >> 1) ^ MAGIC(s);
     }
-  mt->mt_index = idx + sizeof(usize_t);
-  return *(usize_t *)((unsigned char *)b + idx);
+  mt->mt_index = idx + sizeof(uint32_t);
+  return *(uint32_t *)((unsigned char *)b + idx);
 }
 
 static mtrand static_mtrand;
 
 #include <math.h>
 
+static uint32_t
+mt_exp_rand (uint32_t mean, uint32_t max_value)
+{
+  double mean_d = mean;
+  double erand  = log (1.0 / (mt_random (&static_mtrand) / 
+                              (double)UINT32_MAX));
+  uint32_t x = (uint32_t) (mean_d * erand + 0.5);
+
+  return min (x, max_value);
+}
+
 #ifndef WIN32
 #include <sys/wait.h>
 #endif
@@ -103,8 +114,6 @@ static char   TEST_RECON2_FILE[TESTFILESIZE];
 static char   TEST_COPY_FILE[TESTFILESIZE];
 static char   TEST_NOPERM_FILE[TESTFILESIZE];
 
-static int test_exponential_dist (usize_t mean, usize_t max);
-
 #define CHECK(cond) if (!(cond)) { DP(RINT "check failure: " #cond); abort(); }
 
 /* Use a fixed soft config so that test values are fixed.  See also
@@ -149,17 +158,6 @@ static int do_fail (xd3_stream *stream, const char *buf)
   return 0;
 }
 
-static int
-test_exponential_dist (usize_t mean, usize_t max_value)
-{
-  double mean_d = mean;
-  double erand  = log (1.0 / (mt_random (&static_mtrand) / 
-                              (double)USIZE_T_MAX));
-  usize_t x = (usize_t) (mean_d * erand + 0.5);
-
-  return min (x, max_value);
-}
-
 /* Test that the exponential distribution actually produces its mean. */
 static int
 test_random_numbers (xd3_stream *stream, int ignore)
@@ -175,7 +173,7 @@ test_random_numbers (xd3_stream *stream, int ignore)
 
   for (i = 0; i < n_rounds; i += 1)
     {
-      sum += test_exponential_dist (mean, USIZE_T_MAX);
+      sum += mt_exp_rand (mean, USIZE_T_MAX);
     }
 
   average = (double) sum / (double) n_rounds;
@@ -272,7 +270,7 @@ test_make_inputs (xd3_stream *stream, xoff_t *ss_out, xoff_t *ts_out)
   for (i = 0; i < ts; )
     {
       size_t left = ts - i;
-      size_t next = test_exponential_dist (TEST_ADD_MEAN, TEST_ADD_MAX);
+      size_t next = mt_exp_rand (TEST_ADD_MEAN, TEST_ADD_MAX);
       size_t add_left = sadd_max - sadd;
       double add_prob = (left == 0) ? 0 : (add_left / (double) left);
       int do_copy;
@@ -1120,7 +1118,7 @@ sec_dist_func4 (xd3_stream *stream, xd3_output *data)
   int i, ret, x;
   for (i = 0; i < ALPHABET_SIZE*20; i += 1)
     {
-      x = test_exponential_dist (10, ALPHABET_SIZE/2);
+      x = mt_exp_rand (10, ALPHABET_SIZE/2);
       if ((ret = xd3_emit_byte (stream, & data, x))) { return ret; }
     }
   return 0;
@@ -1133,7 +1131,7 @@ sec_dist_func5 (xd3_stream *stream, xd3_output *data)
   int i, ret, x;
   for (i = 0; i < ALPHABET_SIZE*20; i += 1)
     {
-      x = test_exponential_dist (10, ALPHABET_SIZE-1);
+      x = mt_exp_rand (10, ALPHABET_SIZE-1);
       if ((ret = xd3_emit_byte (stream, & data, x))) { return ret; }
     }
   return 0;
diff --git a/xdelta3/xdelta3.c b/xdelta3/xdelta3.c
index 60a348d..77fc534 100644
--- a/xdelta3/xdelta3.c
+++ b/xdelta3/xdelta3.c
@@ -3801,6 +3801,7 @@ xd3_encode_input (xd3_stream *stream)
               else
                 {
                   stream->match_state = MATCH_SEARCHING;
+                  stream->match_fwd = 0;
                 }
               XD3_ASSERT (stream->match_fwd == 0);
 
diff --git a/xdelta3/xdelta3.h b/xdelta3/xdelta3.h
index f5b75d1..fa5b332 100644
--- a/xdelta3/xdelta3.h
+++ b/xdelta3/xdelta3.h
@@ -1207,7 +1207,7 @@ void    xd3_avail_input  (xd3_stream    *stream,
    * xd3_avail_input it will return XD3_INPUT right away without
    * allocating a stream->winsize buffer.  This is to avoid an
    * unwanted allocation. */
-  XD3_ASSERT (idata != NULL);
+  XD3_ASSERT (idata != NULL || isize == 0);
 
   stream->next_in  = idata;
   stream->avail_in = isize;