--- a/src/version.rs	Thu Sep 21 15:35:38 2017 +0200
+++ b/src/version.rs	Thu Sep 21 15:37:25 2017 +0200
@@ -117,7 +117,7 @@
     }
 
     /// level_summary returns a summary of the distribution of tables and bytes in this version.
-    fn level_summary(&self) -> String {
+    pub fn level_summary(&self) -> String {
         let mut acc = String::with_capacity(256);
         for level in 0..NUM_LEVELS {
             let fs = &self.files[level];

--- a/src/version_set.rs	Thu Sep 21 15:35:38 2017 +0200
+++ b/src/version_set.rs	Thu Sep 21 15:37:25 2017 +0200
@@ -7,7 +7,8 @@
 use merging_iter::MergingIter;
 use options::Options;
 use table_cache::TableCache;
-use types::{parse_file_name, share, NUM_LEVELS, FileNum, FileType, LdbIterator, Shared};
+use types::{parse_file_name, share, NUM_LEVELS, FileMetaData, FileNum, FileType, LdbIterator,
+            Shared};
 use version::{new_version_iter, total_size, FileMetaHandle, Version};
 use version_edit::VersionEdit;
 
@@ -18,12 +19,13 @@
 use std::path::Path;
 use std::rc::Rc;
 
-struct Compaction {
+pub struct Compaction {
     level: usize,
     max_file_size: usize,
     input_version: Option<Shared<Version>>,
     level_ixs: [usize; NUM_LEVELS],
     cmp: Rc<Box<Cmp>>,
+    icmp: InternalKeyCmp,
 
     // "parent" inputs from level and level+1.
     inputs: [Vec<FileMetaHandle>; 2],
@@ -44,6 +46,7 @@
             input_version: input,
             level_ixs: Default::default(),
             cmp: opt.cmp.clone(),
+            icmp: InternalKeyCmp(opt.cmp.clone()),
 
             inputs: Default::default(),
             grandparent_ix: 0,
@@ -59,17 +62,31 @@
         self.inputs[parent].push(f)
     }
 
-    fn num_inputs(&self, parent: usize) -> usize {
+    pub fn level(&self) -> usize {
+        self.level
+    }
+
+    pub fn input(&self, parent: usize, ix: usize) -> FileMetaData {
+        assert!(parent < 2);
+        assert!(ix < self.inputs[parent].len());
+        self.inputs[parent][ix].borrow().clone()
+    }
+
+    pub fn num_inputs(&self, parent: usize) -> usize {
         assert!(parent < 2);
         self.inputs[parent].len()
     }
 
-    fn edit(&mut self) -> &mut VersionEdit {
+    pub fn edit(&mut self) -> &mut VersionEdit {
         &mut self.edit
     }
 
+    pub fn into_edit(self) -> VersionEdit {
+        self.edit
+    }
+
     /// add_input_deletions marks the current input files as deleted in the inner VersionEdit.
-    fn add_input_deletions(&mut self) {
+    pub fn add_input_deletions(&mut self) {
         for parent in 0..2 {
             for f in &self.inputs[parent] {
                 self.edit.delete_file(self.level + parent, f.borrow().num);
@@ -80,7 +97,7 @@
     /// is_base_level_for checks whether the given key may exist in levels higher than this
     /// compaction's level plus 2. I.e., whether the levels for this compaction are the last ones
     /// to contain the key.
-    fn is_base_level_for<'a>(&mut self, k: UserKey<'a>) -> bool {
+    pub fn is_base_level_for<'a>(&mut self, k: UserKey<'a>) -> bool {
         assert!(self.input_version.is_some());
         let inp_version = self.input_version.as_ref().unwrap();
         for level in self.level + 2..NUM_LEVELS {
@@ -94,23 +111,23 @@
                     }
                     break;
                 }
+                // level_ixs contains cross-call state to speed up following lookups.
                 self.level_ixs[level] += 1;
             }
         }
         true
     }
 
-    fn is_trivial_move(&self) -> bool {
+    pub fn is_trivial_move(&self) -> bool {
         let inputs_size = total_size(self.grandparents.as_ref().unwrap().iter());
         self.num_inputs(0) == 1 && self.num_inputs(1) == 0 && inputs_size < 10 * self.max_file_size
     }
 
-    fn should_stop_before<'a>(&mut self, k: InternalKey<'a>) -> bool {
+    pub fn should_stop_before<'a>(&mut self, k: InternalKey<'a>) -> bool {
         assert!(self.grandparents.is_some());
         let grandparents = self.grandparents.as_ref().unwrap();
-        let icmp = InternalKeyCmp(self.cmp.clone());
         while self.grandparent_ix < grandparents.len() &&
-              icmp.cmp(k, &grandparents[self.grandparent_ix].borrow().largest) ==
+              self.icmp.cmp(k, &grandparents[self.grandparent_ix].borrow().largest) ==
               Ordering::Greater {
             if self.seen_key {
                 self.overlapped_bytes += grandparents[self.grandparent_ix].borrow().size;
@@ -172,8 +189,12 @@
         }
     }
 
-    /// live_files returns files currently needed.
-    fn live_files(&self) -> Vec<FileNum> {
+    pub fn current_summary(&self) -> String {
+        self.current.as_ref().unwrap().borrow().level_summary()
+    }
+
+    /// live_files returns the files that are currently active.
+    pub fn live_files(&self) -> HashSet<FileNum> {
         let mut files = HashSet::new();
         for version in &self.versions {
             for level in 0..NUM_LEVELS {
@@ -182,7 +203,7 @@
                 }
             }
         }
-        files.into_iter().collect()
+        files
     }
 
     /// release_compaction checks if the input_version of a compaction is held in the VersionSet,
@@ -222,7 +243,8 @@
         assert!(self.current.is_some());
         total_size(self.current.as_ref().unwrap().borrow().files[l].iter())
     }
-    fn num_level_files(&self, l: usize) -> usize {
+
+    pub fn num_level_files(&self, l: usize) -> usize {
         assert!(l < NUM_LEVELS);
         assert!(self.current.is_some());
         self.current.as_ref().unwrap().borrow().files[l].len()
@@ -280,7 +302,7 @@
         offset
     }
 
-    fn pick_compaction(&mut self) -> Option<Compaction> {
+    pub fn pick_compaction(&mut self) -> Option<Compaction> {
         assert!(self.current.is_some());
         let current = self.current();
         let current = current.borrow();
@@ -644,7 +666,7 @@
     }
 
     /// make_input_iterator returns an iterator over the inputs of a compaction.
-    fn make_input_iterator(&self, c: &Compaction) -> Box<LdbIterator> {
+    pub fn make_input_iterator(&self, c: &Compaction) -> Box<LdbIterator> {
         let cap = if c.level == 0 { c.num_inputs(0) + 1 } else { 2 };
         let mut iters: Vec<Box<LdbIterator>> = Vec::with_capacity(cap);
         for i in 0..2 {
@@ -1042,6 +1064,7 @@
         vs.add_version(v);
         // live_files()
         assert_eq!(9, vs.live_files().len());
+        assert!(vs.live_files().contains(&3));
         // num_level_bytes()
         assert_eq!(434, vs.num_level_bytes(0));
         assert_eq!(651, vs.num_level_bytes(1));