Tidy and add docs for cached tree hash

eth2/utils/cached_tree_hash/tests/tests.rs

@@ -9,7 +9,7 @@ fn modifications() {
 
     let vec: Vec<Hash256> = (0..n).map(|_| Hash256::random()).collect();
 
-    let mut cache = TreeHashCache::new(&vec, 0).unwrap();
+    let mut cache = TreeHashCache::new(&vec).unwrap();
     cache.update(&vec).unwrap();
 
     let modifications = cache.chunk_modified.iter().filter(|b| **b).count();
@@ -36,60 +36,57 @@ fn test_routine<T>(original: T, modified: Vec<T>)
 where
     T: CachedTreeHash + std::fmt::Debug,
 {
-    let mut hasher = CachedTreeHasher::new(&original).unwrap();
+    let mut cache = TreeHashCache::new(&original).unwrap();
 
     let standard_root = original.tree_hash_root();
-    let cached_root = hasher.tree_hash_root().unwrap();
+    let cached_root = cache.tree_hash_root().unwrap();
     assert_eq!(standard_root, cached_root, "Initial cache build failed.");
 
     for (i, modified) in modified.iter().enumerate() {
         println!("-- Start of modification {} --", i);
 
         // Update the existing hasher.
-        hasher
+        cache
             .update(modified)
             .expect(&format!("Modification {}", i));
 
         // Create a new hasher from the "modified" struct.
-        let modified_hasher = CachedTreeHasher::new(modified).unwrap();
+        let modified_cache = TreeHashCache::new(modified).unwrap();
 
         assert_eq!(
-            hasher.cache.chunk_modified.len(),
-            modified_hasher.cache.chunk_modified.len(),
+            cache.chunk_modified.len(),
+            modified_cache.chunk_modified.len(),
             "Number of chunks is different"
         );
 
         assert_eq!(
-            hasher.cache.cache.len(),
-            modified_hasher.cache.cache.len(),
+            cache.bytes.len(),
+            modified_cache.bytes.len(),
             "Number of bytes is different"
         );
 
-        assert_eq!(
-            hasher.cache.cache, modified_hasher.cache.cache,
-            "Bytes are different"
-        );
+        assert_eq!(cache.bytes, modified_cache.bytes, "Bytes are different");
 
         assert_eq!(
-            hasher.cache.schemas.len(),
-            modified_hasher.cache.schemas.len(),
+            cache.schemas.len(),
+            modified_cache.schemas.len(),
             "Number of schemas is different"
         );
 
         assert_eq!(
-            hasher.cache.schemas, modified_hasher.cache.schemas,
+            cache.schemas, modified_cache.schemas,
             "Schemas are different"
         );
 
         // Test the root generated by the updated hasher matches a non-cached tree hash root.
         let standard_root = modified.tree_hash_root();
-        let cached_root = hasher
+        let cached_root = cache
             .tree_hash_root()
             .expect(&format!("Modification {}", i));
         assert_eq!(
             standard_root, cached_root,
             "Modification {} failed. \n Cache: {:?}",
-            i, hasher
+            i, cache
         );
     }
 }
@@ -194,20 +191,20 @@ fn test_shrinking_vec_of_vec() {
     let original: Vec<Vec<u64>> = vec![vec![1], vec![2], vec![3], vec![4], vec![5]];
     let modified: Vec<Vec<u64>> = original[0..3].to_vec();
 
-    let new_hasher = CachedTreeHasher::new(&modified).unwrap();
+    let new_cache = TreeHashCache::new(&modified).unwrap();
 
-    let mut modified_hasher = CachedTreeHasher::new(&original).unwrap();
-    modified_hasher.update(&modified).unwrap();
+    let mut modified_cache = TreeHashCache::new(&original).unwrap();
+    modified_cache.update(&modified).unwrap();
 
     assert_eq!(
-        new_hasher.cache.schemas.len(),
-        modified_hasher.cache.schemas.len(),
+        new_cache.schemas.len(),
+        modified_cache.schemas.len(),
         "Schema count is different"
     );
 
     assert_eq!(
-        new_hasher.cache.chunk_modified.len(),
-        modified_hasher.cache.chunk_modified.len(),
+        new_cache.chunk_modified.len(),
+        modified_cache.chunk_modified.len(),
         "Chunk count is different"
     );
 }
@@ -601,7 +598,7 @@ fn generic_test(index: usize) {
         d: 4,
     };
 
-    let mut cache = TreeHashCache::new(&inner, 0).unwrap();
+    let mut cache = TreeHashCache::new(&inner).unwrap();
 
     let changed_inner = match index {
         0 => Inner {
@@ -636,7 +633,7 @@ fn generic_test(index: usize) {
 
     let expected = merkleize(join(data));
 
-    let cache_bytes: Vec<u8> = cache.into();
+    let (cache_bytes, _, _) = cache.into_components();
 
     assert_eq!(expected, cache_bytes);
 }
@@ -666,9 +663,9 @@ fn inner_builds() {
         d: 4,
     };
 
-    let cache: Vec<u8> = TreeHashCache::new(&inner, 0).unwrap().into();
+    let (cache_bytes, _, _) = TreeHashCache::new(&inner).unwrap().into_components();
 
-    assert_eq!(expected, cache);
+    assert_eq!(expected, cache_bytes);
 }
 
 fn join(many: Vec<Vec<u8>>) -> Vec<u8> {