A test is taking shape...

8 files changed, 591 insertions, 286 deletions

diff --git a/xdelta3/testing/Makefile b/xdelta3/testing/Makefile
index a6cd152..50b6e04 100755
--- a/xdelta3/testing/Makefile
+++ b/xdelta3/testing/Makefile
@@ -1,13 +1,13 @@
 CFLAGS = -g -Wall -I.. -DXD3_DEBUG=1 -DNDEBUG=0
 
-DEPS = ../*.h ../*.c *.cc
+DEPS = ../*.h ../*.c *.cc *.h
 
 TARGETS = xdelta3-regtest
 
 all: $(TARGETS)
 
 xdelta3-regtest: $(DEPS)
-        $(CXX) $(CFLAGS) xdelta3-regtest.cc -o xdelta3-regtest
+        $(CXX) $(CFLAGS) regtest.cc -o xdelta3-regtest
 
 clean:
         rm -f *.exe *.stackdump $(TARGETS)
diff --git a/xdelta3/testing/cmp.h b/xdelta3/testing/cmp.h
new file mode 100644
index 0000000..12b499d
--- /dev/null
+++ b/xdelta3/testing/cmp.h
@@ -0,0 +1,37 @@
+/* -*- Mode: C++ -*-  */
+namespace regtest {
+
+inline xoff_t CmpDifferentBytes(const FileSpec &a, const FileSpec &b) {
+  Block block_a, block_b;
+  xoff_t total = 0;
+  FileSpec::iterator a_i(a), b_i(b);
+
+  for (; !a_i.Done() && !b_i.Done(); a_i.Next(), b_i.Next()) {
+
+    a_i.Get(&block_a);
+    b_i.Get(&block_b);
+
+    size_t i = 0; 
+    size_t m = min(block_a.Size(), block_b.Size());
+
+    for (; i < m; i++) {
+      if (block_a[i] != block_b[i]) {
+        total++;
+      }
+    }
+
+    total += block_a.Size() - i;
+    total += block_b.Size() - i;
+  }
+
+  for (; !a_i.Done(); a_i.Next()) {
+    total += a_i.BytesOnBlock();
+  }
+  for (; !b_i.Done(); b_i.Next()) {
+    total += b_i.BytesOnBlock();
+  }
+
+  return total;
+}
+
+}  // namespace regtest
diff --git a/xdelta3/testing/file.h b/xdelta3/testing/file.h
new file mode 100644
index 0000000..4dbb07d
--- /dev/null
+++ b/xdelta3/testing/file.h
@@ -0,0 +1,172 @@
+/* -*- Mode: C++ -*-  */
+namespace regtest {
+
+class Segment {
+ public:
+  Segment(uint32_t seed, size_t length)
+    : seed(seed),
+      length(length),
+      seed_offset(0) { }
+
+  uint32_t seed;  // Seed used for generating byte sequence
+  size_t length;  // Length of this segment
+  size_t seed_offset;  // Seed positions the sequence this many bytes
+                       // before its beginning.
+};
+
+typedef map<xoff_t, Segment> SegmentMap;
+
+class Block;
+class BlockIterator;
+
+class FileSpec {
+ public:
+  FileSpec(MTRandom *rand)
+    : rand_(rand) {
+  }
+
+  // Generates a file with a known size
+  void GenerateFixedSize(xoff_t size) {
+    Reset();
+    
+    for (xoff_t p = 0; p < size; ) {
+      xoff_t t = min(Constants::BLOCK_SIZE, size - p);
+      table_.insert(make_pair(p, Segment(rand_->Rand32(), t)));
+      p += t;
+    }
+  }
+
+  // Generates a file with exponential-random distributed size
+  void GenerateRandomSize(xoff_t mean) {
+    GenerateFixedSize(rand_->ExpRand(mean));
+  }
+
+  // Returns the size of the file
+  xoff_t Size() const {
+    if (table_.empty()) {
+      return 0;
+    }
+    SegmentMap::const_iterator i = --table_.end();
+    return i->first + i->second.length;
+  }
+
+  // Returns the number of blocks
+  xoff_t Blocks() const {
+    if (table_.empty()) {
+      return 0;
+    }
+    return ((Size() - 1) / Constants::BLOCK_SIZE) + 1;
+  }
+
+  // Returns the number of segments
+  xoff_t Segments() const {
+    return table_.size();
+  }
+
+  // Create a mutation according to "what".
+  template <typename T>
+  void ModifyTo(FileSpec *modify) const {
+    modify->table_ = table_;
+    T::Mutate(&modify->table_, rand_);
+  }
+
+  void Reset() {
+    table_.clear();
+  }
+
+  typedef BlockIterator iterator;
+
+ private:
+  friend class BlockIterator;
+
+  MTRandom *rand_;
+  SegmentMap table_;
+};
+
+class Block {
+public:
+  Block()
+    : data_(new uint8_t[Constants::BLOCK_SIZE]) { }
+  ~Block() {
+    delete [] data_;
+  }
+    
+  size_t Size() const {
+    return size_;
+  }
+  uint8_t operator[](size_t i) const {
+    CHECK_LT(i, Constants::BLOCK_SIZE);
+    return data_[i];
+  }
+
+private:
+  friend class BlockIterator;
+
+  size_t size_;
+  uint8_t *data_;
+};
+
+class BlockIterator {
+public:
+  BlockIterator(const FileSpec& spec)
+    : spec_(spec),
+      blkno_(0) { }
+
+  bool Done() const {
+    return blkno_ >= spec_.Blocks();
+  }
+
+  void Next() {
+    blkno_++;
+  }
+
+  void Get(Block *block) const;
+
+  size_t BytesOnBlock() const {
+    // Blocks() is unsigned, don't subtract
+    if (blkno_ + 1 < spec_.Blocks()) {
+      return Constants::BLOCK_SIZE;
+    }
+    return spec_.Size() % Constants::BLOCK_SIZE;
+  }
+
+private:
+  const FileSpec& spec_;
+  xoff_t blkno_;
+};
+
+inline void BlockIterator::Get(Block *block) const {
+  xoff_t offset = blkno_ * Constants::BLOCK_SIZE;
+  const SegmentMap &table = spec_.table_;
+  size_t got = 0;
+  block->size_ = BytesOnBlock();
+
+  SegmentMap::const_iterator pos = table.upper_bound(offset);
+  --pos;
+
+  while (got < block->size_) {
+    CHECK(pos != table.end());
+    CHECK_GE(offset, pos->first);
+
+    // The position of this segment may start before this block starts,
+    // and then the position of the data may be offset from the seeding 
+    // position.
+    size_t seg_offset = offset - pos->first;
+    xoff_t skip = seg_offset + pos->second.seed_offset;
+    MTRandom gen(pos->second.seed);
+    while (skip--) {
+      gen.Rand32();
+    }
+    
+    for (size_t i = seg_offset; i < pos->second.length; i++) {
+      CHECK_LT(got, Constants::BLOCK_SIZE);
+      block->data_[got++] = gen.Rand32();
+    }
+
+    offset += (pos->second.length - seg_offset);
+    ++pos;
+  }
+}
+
+}  // namespace regtest
+
diff --git a/xdelta3/testing/modify.h b/xdelta3/testing/modify.h
new file mode 100644
index 0000000..8d6b480
--- /dev/null
+++ b/xdelta3/testing/modify.h
@@ -0,0 +1,23 @@
+/* -*- Mode: C++ -*-  */
+namespace regtest {
+
+class Modify1stByte {
+ public:
+  static void Mutate(SegmentMap *table, MTRandom *rand) {
+    CHECK(!table->empty());
+
+    SegmentMap::iterator i1 = table->begin();
+    CHECK_EQ(0, i1->first);
+    
+    if (i1->second.length == 1) {
+      i1->second.seed = rand->Rand32();
+    } else {
+      i1->second.seed_offset += 1;
+      i1->second.length -= 1;
+      table->insert(make_pair(1, i1->second));
+      i1->second = Segment(rand->Rand32(), 1);
+    }
+  }
+};
+
+}  // namespace regtest
diff --git a/xdelta3/testing/random.h b/xdelta3/testing/random.h
new file mode 100644
index 0000000..6648edb
--- /dev/null
+++ b/xdelta3/testing/random.h
@@ -0,0 +1,125 @@
+/* -*- Mode: C++ -*-  */
+/* This is public-domain Mersenne Twister code,
+ * attributed to Michael Brundage.  Thanks!
+ * http://www.qbrundage.com/michaelb/pubs/essays/random_number_generation.html
+ */
+#include <math.h>
+
+namespace regtest {
+
+class MTRandom {
+ public:
+  static const uint32_t TEST_SEED1 = 0x1975;
+
+  static const int MT_LEN = 624;
+  static const int MT_IA = 397;
+  static const int MT_IB = (MT_LEN - MT_IA);
+  static const uint32_t UPPER_MASK = 0x80000000;
+  static const uint32_t LOWER_MASK = 0x7FFFFFFF;
+  static const uint32_t MATRIX_A = 0x9908B0DF;
+
+  MTRandom() {
+    Init(TEST_SEED1);
+  }
+
+  MTRandom(uint32_t seed) {
+    Init(seed);
+  }
+
+  uint32_t TWIST(int i, int j) {
+    return (mt_buffer_[i] & UPPER_MASK) | (mt_buffer_[j] & LOWER_MASK);
+  }
+
+  uint32_t MAGIC(uint32_t s) {
+    return (s & 1) * MATRIX_A;
+  }
+
+  uint32_t Rand32 () {
+    int idx = mt_index_;
+    uint32_t s;
+    int i;
+        
+    if (idx == MT_LEN * sizeof(uint32_t)) {
+      idx = 0;
+      i = 0;
+      for (; i < MT_IB; i++) {
+        s = TWIST(i, i+1);
+        mt_buffer_[i] = mt_buffer_[i + MT_IA] ^ (s >> 1) ^ MAGIC(s);
+      }
+      for (; i < MT_LEN-1; i++) {
+        s = TWIST(i, i+1);
+        mt_buffer_[i] = mt_buffer_[i - MT_IB] ^ (s >> 1) ^ MAGIC(s);
+      }
+        
+      s = TWIST(MT_LEN-1, 0);
+      mt_buffer_[MT_LEN-1] = mt_buffer_[MT_IA-1] ^ (s >> 1) ^ MAGIC(s);
+    }
+    mt_index_ = idx + sizeof(uint32_t);
+
+    // Original code had an unaligned access, make it portable.
+    //   return *(uint32_t *)((unsigned char *)b + idx);
+    uint32_t r;
+    memcpy(&r, ((unsigned char *)mt_buffer_ + idx), sizeof(uint32_t));
+    return r;
+  }
+
+  uint32_t ExpRand32(uint32_t mean) {
+    double mean_d = mean;
+    double erand  = log (1.0 / (Rand32() / (double)UINT32_MAX));
+    uint32_t x = (uint32_t) (mean_d * erand + 0.5);
+    return x;
+  }
+
+  uint64_t Rand64() {
+    return ((uint64_t)Rand32() << 32) | Rand32();
+  }
+
+  uint64_t ExpRand64(uint64_t mean) {
+    double mean_d = mean;
+    double erand  = log (1.0 / (Rand64() / (double)UINT32_MAX));
+    uint64_t x = (uint64_t) (mean_d * erand + 0.5);
+    return x;
+  }
+
+  template <typename T>
+  T Rand() {
+    switch (sizeof(T)) {
+    case sizeof(uint32_t):
+      return Rand32();
+    case sizeof(uint64_t):
+      return Rand64();
+    default:
+      cerr << "Invalid sizeof T" << endl;
+      abort();
+    }
+  }
+
+  template <typename T>
+  T ExpRand(T mean) {
+    switch (sizeof(T)) {
+    case sizeof(uint32_t):
+      return ExpRand32(mean);
+    case sizeof(uint64_t):
+      return ExpRand64(mean);
+    default:
+      cerr << "Invalid sizeof T" << endl;
+      abort();
+    }
+  }
+
+ private:
+  void Init(uint32_t seed) {
+    int i;
+    srand (seed);
+    for (i = 0; i < MT_LEN; i++)
+      {
+        mt_buffer_[i] = rand ();
+      }
+    mt_index_ = 0;
+  }
+
+  int mt_index_;
+  uint32_t mt_buffer_[MT_LEN];
+};
+
+}  // namespace regtest
diff --git a/xdelta3/testing/regtest.cc b/xdelta3/testing/regtest.cc
new file mode 100644
index 0000000..489b58a
--- /dev/null
+++ b/xdelta3/testing/regtest.cc
@@ -0,0 +1,173 @@
+/* -*- Mode: C++ -*-  */
+#include "test.h"
+
+// Declare constants (needed for reference-values, etc).
+const xoff_t Constants::BLOCK_SIZE;
+
+void TestRandomNumbers() {
+  MTRandom rand;
+  int rounds = 1<<20;
+  uint64_t usum = 0;
+  uint64_t esum = 0;
+
+  for (int i = 0; i < rounds; i++) {
+    usum += rand.Rand32();
+    esum += rand.ExpRand32(1024);
+  }
+  
+  double allowed_error = 0.001;
+
+  uint32_t umean = usum / rounds;
+  uint32_t emean = esum / rounds;
+
+  uint32_t uexpect = UINT32_MAX / 2;
+  uint32_t eexpect = 1024;
+
+  if (umean < uexpect * (1.0 - allowed_error) ||
+      umean > uexpect * (1.0 + allowed_error)) {
+    cerr << "uniform mean error: " << umean << " != " << uexpect << endl;
+    abort();
+  }
+
+  if (emean < eexpect * (1.0 - allowed_error) ||
+      emean > eexpect * (1.0 + allowed_error)) {
+    cerr << "exponential mean error: " << emean << " != " << eexpect << endl;
+    abort();
+  }
+}
+
+void TestRandomFile() {
+  MTRandom rand1;
+  FileSpec spec1(&rand1);
+
+  spec1.GenerateFixedSize(0);
+  CHECK_EQ(0, spec1.Size());
+  CHECK_EQ(0, spec1.Segments());
+  CHECK_EQ(0, spec1.Blocks());
+
+  spec1.GenerateFixedSize(1);
+  CHECK_EQ(1, spec1.Size());
+  CHECK_EQ(1, spec1.Segments());
+  CHECK_EQ(1, spec1.Blocks());
+
+  spec1.GenerateFixedSize(Constants::BLOCK_SIZE);
+  CHECK_EQ(Constants::BLOCK_SIZE, spec1.Size());
+  CHECK_EQ(1, spec1.Segments());
+  CHECK_EQ(1, spec1.Blocks());
+
+  spec1.GenerateFixedSize(Constants::BLOCK_SIZE + 1);
+  CHECK_EQ(Constants::BLOCK_SIZE + 1, spec1.Size());
+  CHECK_EQ(2, spec1.Segments());
+  CHECK_EQ(2, spec1.Blocks());
+
+  spec1.GenerateFixedSize(Constants::BLOCK_SIZE * 2);
+  CHECK_EQ(Constants::BLOCK_SIZE * 2, spec1.Size());
+  CHECK_EQ(2, spec1.Segments());
+  CHECK_EQ(2, spec1.Blocks());
+}
+
+void TestFirstByte() {
+  MTRandom rand;
+  FileSpec spec0(&rand);
+  FileSpec spec1(&rand);
+  spec0.GenerateFixedSize(0);
+  spec1.GenerateFixedSize(1);
+  CHECK_EQ(0, CmpDifferentBytes(spec0, spec0));
+  CHECK_EQ(0, CmpDifferentBytes(spec1, spec1));
+  CHECK_EQ(1, CmpDifferentBytes(spec0, spec1));
+  CHECK_EQ(1, CmpDifferentBytes(spec1, spec0));
+
+  spec0.GenerateFixedSize(1);
+  spec0.ModifyTo<Modify1stByte>(&spec1);
+  CHECK_EQ(1, CmpDifferentBytes(spec0, spec1));
+
+  spec0.GenerateFixedSize(Constants::BLOCK_SIZE + 1);
+  spec0.ModifyTo<Modify1stByte>(&spec1);
+  CHECK_EQ(1, CmpDifferentBytes(spec0, spec1));
+}
+
+int main(int argc, char **argv) {
+#define TEST(x) cerr << #x << "..." << endl; x()
+  TEST(TestRandomNumbers);
+  TEST(TestRandomFile);
+  TEST(TestFirstByte);
+  return 0;
+}
+
+#if 0
+static const random_parameters test_parameters[] = {
+  { 16384, 4096, 16, 0 },
+  { 16384, 4096, 0, 16 },
+  { 16384, 4096, 16, 16 },
+  { 16384, 4096, 128, 128 },
+};
+
+int
+test_merge_chain (random_file_spec *specs, int number)
+{
+  /* "number" is from 1 (a single delta) between specs[0] and
+   * specs[1], to N, an (N-1) chain from specs[0] to specs[N]. */
+  return 0;
+}
+
+static int
+test_merge_command ()
+{
+  /* Repeat random-input testing for a number of iterations.
+   * Test 2, 3, and 4-file scenarios (i.e., 1, 2, and 3-delta merges). */
+  int ret;
+  int iter = 0, param = 0;
+  random_file_spec spec[4];
+
+  memset (spec, 0, sizeof (spec));
+
+  /* Repeat this loop for TESTS_PER_PARAMETER * #parameters * 2.  The
+   * first #parameters repeats are for the provided values, the second
+   * set of repeats use random parameters. */
+  for (; param < (2 * SIZEOF_ARRAY(test_parameters)); iter++)
+    {
+      if (iter % TESTS_PER_PARAMETER == 0)
+        {
+          if (param < SIZEOF_ARRAY(test_parameters))
+            {
+              set_test_parameters (&test_parameters[param]);
+            } 
+          else 
+            {
+              set_random_parameters ();
+            }
+
+          param++;
+
+          if ((ret = random_file_spec_generate (&spec[0]))) { return ret; }
+          if ((ret = random_file_spec_write (&spec[0]))) { return ret; }
+
+          if ((ret = random_file_spec_mutate (&spec[0], &spec[1]))) { return ret; }
+          if ((ret = random_file_spec_write (&spec[1]))) { return ret; }
+          if ((ret = random_file_spec_delta (&spec[0], &spec[1]))) { return ret; }
+
+          if ((ret = random_file_spec_mutate (&spec[1], &spec[2]))) { return ret; }
+          if ((ret = random_file_spec_write (&spec[2]))) { return ret; }
+          if ((ret = random_file_spec_delta (&spec[1], &spec[2]))) { return ret; }
+        }
+
+      /* Each iteration creates a new mutation. */
+      if ((ret = random_file_spec_mutate (&spec[2], &spec[3]))) { return ret; }
+      if ((ret = random_file_spec_write (&spec[3]))) { return ret; }
+      if ((ret = random_file_spec_delta (&spec[2], &spec[3]))) { return ret; }
+
+      /* Test 1, 2, and 3 */
+      if ((ret = test_merge_chain (spec, 1))) { return ret; }
+      if ((ret = test_merge_chain (spec, 2))) { return ret; }
+      if ((ret = test_merge_chain (spec, 3))) { return ret; }
+
+      /* Clear 1st input, shift inputs */
+      random_file_spec_clear (&spec[0]);
+      random_file_spec_swap (&spec[0], &spec[1]);
+      random_file_spec_swap (&spec[1], &spec[2]);
+      random_file_spec_swap (&spec[2], &spec[3]);
+    }
+
+  return 0;
+}
+#endif
diff --git a/xdelta3/testing/test.h b/xdelta3/testing/test.h
new file mode 100644
index 0000000..dcec6d9
--- /dev/null
+++ b/xdelta3/testing/test.h
@@ -0,0 +1,59 @@
+/* -*- Mode: C++ -*-  */
+
+extern "C" {
+#define NOT_MAIN 1
+#define REGRESSION_TEST 0
+#include "../xdelta3.c"
+}
+
+#define CHECK_EQ(x,y) CHECK_OP(x,y,==)
+#define CHECK_LT(x,y) CHECK_OP(x,y,<)
+#define CHECK_GT(x,y) CHECK_OP(x,y,>)
+#define CHECK_LE(x,y) CHECK_OP(x,y,<=)
+#define CHECK_GE(x,y) CHECK_OP(x,y,>=)
+
+#define CHECK_OP(x,y,OP) \
+do {if (!((x) OP (y))) {                               \
+  cerr << "Check failed: " << #x " " #OP " " #y << endl; \
+  cerr << "Expected: " << x << endl; \
+  cerr << "Actual: " << y << endl; \
+  abort(); \
+    } } while (false)
+
+#define CHECK(x) \
+  do {if (!(x)) {                                      \
+  cerr << "Check failed: " << #x << endl; \
+  abort(); \
+    } } while (false)
+
+#include <iostream>
+using std::cerr;
+using std::endl;
+
+#include <map> 
+using std::map;
+using std::pair;
+
+template <typename T, typename U>
+pair<T, U> make_pair(const T& t, const U& u) {
+  return pair<T, U>(t, u);
+}
+
+class Constants {
+public:
+  static const xoff_t BLOCK_SIZE = 1 << 14;
+};
+
+using std::min;
+
+#include "random.h"
+using regtest::MTRandom;
+
+#include "file.h"
+using regtest::FileSpec;
+
+#include "modify.h"
+using regtest::Modify1stByte;
+
+#include "cmp.h"
+using regtest::CmpDifferentBytes;
diff --git a/xdelta3/testing/xdelta3-regtest.cc b/xdelta3/testing/xdelta3-regtest.cc
deleted file mode 100644
index a43ed92..0000000
--- a/xdelta3/testing/xdelta3-regtest.cc
+++ /dev/null
@@ -1,284 +0,0 @@
-/* xdelta 3 - delta compression tools and library
- * Copyright (C) 2001, 2003, 2004, 2005, 2006, 2007, 2008. Joshua P. MacDonald
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-// This file started because I wanted to write a test in C++ rather than C.
-
-extern "C" {
-#define NOT_MAIN 1
-#define REGRESSION_TEST 1
-#include "../xdelta3.c"
-}
-
-namespace {
-
-const int TEST_SEED1 = 0x1970;
-
-class RandomFileSpec {
- public:
-  RandomFileSpec()
-    : size_(0),
-      seed_(0),
-      filedata_(NULL),
-      filename_(NULL),
-      deltafile_(NULL) {
-    main_file_init(&file_);
-    mt_init(&mt_, TEST_SEED1);
-  }
-  int size_;
-  int seed_;
-  uint8_t *filedata_;
-  char *filename_;
-  char *deltafile_;
-  main_file file_;
-  mtrand mt_;
-};
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  RandomFileSpec spec1;
-
-  return 0;
-}
-
-
-#if 0
-static const int TESTS_PER_PARAMETER = 100;
-
-struct random_file_spec_ {
-  int size;
-  int seed;
-  main_file file;
-  uint8_t *tmp_data;
-  char *tmp_copy;
-  char *tmp_delta;
-  mtrand mt;
-};
-
-struct random_parameters_ {
-  int file_size;
-  int window_size;
-  int add_size;
-  int del_size;
-};
-
-typedef struct random_file_spec_ random_file_spec;
-typedef struct random_parameters_ random_parameters;
-
-static const random_parameters test_parameters[] = {
-  { 16384, 4096, 16, 0 },
-  { 16384, 4096, 0, 16 },
-  { 16384, 4096, 16, 16 },
-  { 16384, 4096, 128, 128 },
-};
-
-static random_parameters current_parameters;
-static int test2_malloc_count;
-
-void 
-set_test_parameters (const random_parameters *params)
-{
-  current_parameters = *params;
-}
-
-void 
-set_random_parameters ()
-{
-  // TODO(jmacd)
-  current_parameters = test_parameters[0];
-}
-
-void*
-test2_malloc (int size)
-{
-  test2_malloc_count++;
-  return malloc(size);
-}
-
-void 
-test2_free (void *ptr)
-{
-  test2_malloc_count--;
-  free (ptr);
-  XD3_ASSERT (test2_malloc_count >= 0);
-}
-
-void
-random_file_spec_clear (random_file_spec *spec)
-{
-  if (spec->tmp_copy)
-    {
-      unlink (spec->tmp_copy);  /* TODO(jmacd): make portable */
-      test2_free (spec->tmp_copy);
-      spec->tmp_copy = NULL;
-    }
-
-  if (spec->tmp_delta)
-    {
-      unlink (spec->tmp_delta);
-      test2_free (spec->tmp_delta);
-      spec->tmp_delta = NULL;
-    }
-
-  if (spec->tmp_data)
-    {
-      test2_free (spec->tmp_data);
-      spec->tmp_data = NULL;
-    }
-}
-
-void 
-random_file_spec_swap (random_file_spec *a, 
-                       random_file_spec *b)
-{
-  random_file_spec t = *a;
-  *a = *b;
-  *b = t;
-}
-
-int
-random_file_spec_generate (random_file_spec *spec) 
-{
-  int i;
-  spec->seed = mt_random (&static_mtrand);
-  mt_init (&spec->mt, spec->seed);
-  main_file_init (&spec->file);
-
-  test_setup();
-  spec->tmp_copy = test2_malloc(strlen(TEST_TARGET_FILE) + 1);
-  strcpy (spec->tmp_copy, TEST_TARGET_FILE);
-
-  spec->size = current_parameters.file_size;
-  spec->tmp_data = (uint8_t*)test2_malloc(spec->size);
-
-  for (i = 0; i < spec->size; i++)
-    {
-      spec->tmp_data[i] = mt_random(&spec->mt);
-    }
-
-  return 0;
-}
-
-int
-random_file_spec_write (random_file_spec *spec) 
-{
-  int ret;
-  if ((ret = main_file_open (&spec->file, spec->tmp_copy, XO_WRITE)) ||
-      (ret = main_file_write (&spec->file, spec->tmp_data, spec->size,
-                              "write failed")) ||
-      (ret = main_file_close (&spec->file)))
-    {
-      return ret;
-    }
-
-  return 0;
-}
-
-int
-random_file_spec_mutate (random_file_spec *from, random_file_spec *to)
-{
-  to->seed = mt_random (&static_mtrand);
-  mt_init (&to->mt, to->seed);
-  main_file_init (&spec->file);
-
-  test_setup();
-  spec->tmp_copy = test2_malloc(strlen(TEST_TARGET_FILE) + 1);
-  strcpy (spec->tmp_copy, TEST_TARGET_FILE);
-
-  spec->size = current_parameters.file_size;
-  spec->tmp_data = (uint8_t*)test2_malloc(spec->size);
-
-
-  return 0;
-}
-
-int
-random_file_spec_delta (random_file_spec *from, random_file_spec *to)
-{
-  return 0;
-}
-
-int
-test_merge_chain (random_file_spec *specs, int number)
-{
-  /* "number" is from 1 (a single delta) between specs[0] and
-   * specs[1], to N, an (N-1) chain from specs[0] to specs[N]. */
-  return 0;
-}
-
-static int
-test_merge_command ()
-{
-  /* Repeat random-input testing for a number of iterations.
-   * Test 2, 3, and 4-file scenarios (i.e., 1, 2, and 3-delta merges). */
-  int ret;
-  int iter = 0, param = 0;
-  random_file_spec spec[4];
-
-  memset (spec, 0, sizeof (spec));
-
-  /* Repeat this loop for TESTS_PER_PARAMETER * #parameters * 2.  The
-   * first #parameters repeats are for the provided values, the second
-   * set of repeats use random parameters. */
-  for (; param < (2 * SIZEOF_ARRAY(test_parameters)); iter++)
-    {
-      if (iter % TESTS_PER_PARAMETER == 0)
-        {
-          if (param < SIZEOF_ARRAY(test_parameters))
-            {
-              set_test_parameters (&test_parameters[param]);
-            } 
-          else 
-            {
-              set_random_parameters ();
-            }
-
-          param++;
-
-          if ((ret = random_file_spec_generate (&spec[0]))) { return ret; }
-          if ((ret = random_file_spec_write (&spec[0]))) { return ret; }
-
-          if ((ret = random_file_spec_mutate (&spec[0], &spec[1]))) { return ret; }
-          if ((ret = random_file_spec_write (&spec[1]))) { return ret; }
-          if ((ret = random_file_spec_delta (&spec[0], &spec[1]))) { return ret; }
-
-          if ((ret = random_file_spec_mutate (&spec[1], &spec[2]))) { return ret; }
-          if ((ret = random_file_spec_write (&spec[2]))) { return ret; }
-          if ((ret = random_file_spec_delta (&spec[1], &spec[2]))) { return ret; }
-        }
-
-      /* Each iteration creates a new mutation. */
-      if ((ret = random_file_spec_mutate (&spec[2], &spec[3]))) { return ret; }
-      if ((ret = random_file_spec_write (&spec[3]))) { return ret; }
-      if ((ret = random_file_spec_delta (&spec[2], &spec[3]))) { return ret; }
-
-      /* Test 1, 2, and 3 */
-      if ((ret = test_merge_chain (spec, 1))) { return ret; }
-      if ((ret = test_merge_chain (spec, 2))) { return ret; }
-      if ((ret = test_merge_chain (spec, 3))) { return ret; }
-
-      /* Clear 1st input, shift inputs */
-      random_file_spec_clear (&spec[0]);
-      random_file_spec_swap (&spec[0], &spec[1]);
-      random_file_spec_swap (&spec[1], &spec[2]);
-      random_file_spec_swap (&spec[2], &spec[3]);
-    }
-
-  return 0;
-}
-#endif