Add testing for move/copy mutators.

1 files changed, 112 insertions, 7 deletions

diff --git a/xdelta3/testing/modify.h b/xdelta3/testing/modify.h
index 2f3e752..ac2286a 100644
--- a/xdelta3/testing/modify.h
+++ b/xdelta3/testing/modify.h
@@ -14,8 +14,9 @@ public:
   enum Kind {
     MODIFY = 1,
     ADD = 2,
-    MOVE = 3,
-    DELETE = 4,
+    DELETE = 3,
+    MOVE = 4,
+    COPY = 5,
   };
 
   // Constructor for modify, add, delete.
@@ -23,15 +24,16 @@ public:
     : kind(kind),
       size(size),
       addr1(addr1) { 
-    CHECK_NE(kind, MOVE);
+    CHECK(kind != MOVE && kind != COPY);
   }
 
   // Constructor for move
   Change(Kind kind, xoff_t size, xoff_t addr1, xoff_t addr2)
     : kind(kind),
       size(size),
-      addr1(addr1) { 
-    CHECK_EQ(kind, MOVE);
+      addr1(addr1),
+      addr2(addr2) { 
+    CHECK(kind == MOVE || kind == COPY);
   }
 
   Kind kind;
@@ -78,6 +80,17 @@ public:
                          const SegmentMap *source_table,
                          MTRandom *rand);
 
+  static void CopyChange(const Change &ch, 
+                         SegmentMap *table,
+                         const SegmentMap *source_table,
+                         MTRandom *rand);
+
+  static void AppendCopy(SegmentMap *table,
+                         const SegmentMap *source_table,
+                         xoff_t copy_offset, 
+                         xoff_t append_offset, 
+                         xoff_t length);
+
   ChangeList* Changes() {
     return &cl_;
   }
@@ -119,11 +132,14 @@ void ChangeListMutator::Mutate(const Change &ch,
   case Change::DELETE:
     DeleteChange(ch, table, source_table, rand);
     break;
+  case Change::COPY:
+    CopyChange(ch, table, source_table, rand);
+    break;
   case Change::MOVE:
-    //MoveChange(ch, table, source_table, rand);
+    MoveChange(ch, table, source_table, rand);
     break;
   }
-}  
+}
 
 void ChangeListMutator::ModifyChange(const Change &ch, 
                                      SegmentMap *table,
@@ -258,6 +274,95 @@ void ChangeListMutator::DeleteChange(const Change &ch,
   CHECK_LE(m_end, i_end);
 }
 
+void ChangeListMutator::MoveChange(const Change &ch, 
+                                   SegmentMap *table,
+                                   const SegmentMap *source_table,
+                                   MTRandom *rand) {
+  SegmentMap tmp;
+  CHECK_NE(ch.addr1, ch.addr2);
+  CopyChange(ch, &tmp, source_table, rand);
+  Change d(Change::DELETE, ch.size, 
+           ch.addr1 < ch.addr2 ? ch.addr1 : ch.addr1 + ch.size);
+  DeleteChange(d, table, &tmp, rand);
+}
+
+void ChangeListMutator::CopyChange(const Change &ch, 
+                                   SegmentMap *table,
+                                   const SegmentMap *source_table,
+                                   MTRandom *ignore) {
+  xoff_t m_start = ch.addr2;
+  xoff_t c_start = ch.addr1;
+  xoff_t i_start = 0;
+  xoff_t i_end = 0;
+
+  // Like AddChange() with AppendCopy instead of a random segment.
+  for (SegmentMap::const_iterator iter(source_table->begin()); 
+       iter != source_table->end();
+       ++iter) {
+    const Segment &seg = iter->second;
+    i_start = iter->first;
+    i_end = i_start + seg.length;
+
+    if (i_end <= m_start) {
+      table->insert(table->end(), make_pair(i_start, seg));
+      continue;
+    }
+
+    if (i_start > m_start) {
+      table->insert(table->end(), make_pair(i_start + ch.size, seg));
+      continue;
+    }
+
+    if (i_start < m_start) {
+      Segment before(seg.seed, m_start - i_start, seg.seed_offset);
+      table->insert(table->end(), make_pair(i_start, before));
+    }
+
+    AppendCopy(table, source_table, c_start, m_start, ch.size);
+
+    if (m_start < i_end) {
+      Segment after(seg.seed, i_end - m_start, 
+                    seg.seed_offset + (m_start - i_start));
+      table->insert(table->end(), make_pair(m_start + ch.size, after));
+    }
+  }
+
+  CHECK_LE(m_start, i_end);
+
+  // Special case for copy to end-of-input.
+  if (m_start == i_end) {
+    AppendCopy(table, source_table, c_start, m_start, ch.size);
+  }
+}
+
+void ChangeListMutator::AppendCopy(SegmentMap *table,
+                                   const SegmentMap *source_table,
+                                   xoff_t copy_offset, 
+                                   xoff_t append_offset,
+                                   xoff_t length) {
+  SegmentMap::const_iterator pos(source_table->upper_bound(copy_offset));
+  --pos;
+  xoff_t got = 0;
+
+  while (got < length) {
+    size_t seg_offset = copy_offset - pos->first;
+    xoff_t skip = seg_offset + pos->second.seed_offset;
+    size_t advance = min(pos->second.length - seg_offset, 
+                         (size_t)(length - got));
+
+    table->insert(table->end(), 
+                  make_pair(append_offset,
+                            Segment(pos->second.seed, 
+                                    advance,
+                                    skip)));
+
+    got += advance;
+    copy_offset += advance;
+    append_offset += advance;
+    ++pos;
+  }
+}
+
 class Modify1stByte : public Mutator {
 public:
   void Mutate(SegmentMap *table,