Qortal/pirate-librustzcash
3
0
Fork 0
mirror of https://github.com/Qortal/pirate-librustzcash.git synced 2025-01-31 07:42:15 +00:00
Code Issues Projects Releases Wiki Activity

refactor numerous tests

Browse Source
This commit is contained in:
NikVolf 2019-09-06 19:14:53 +03:00
parent 5d2f84a154
commit 942a976ef5
1 changed files with 85 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
src/tree.rs
View File

@ -23,24 +23,6 @@ pub struct Tree {
root: EntryLink, root: EntryLink,
} }
/// Result of appending one or several leaves.
pub struct AppendTransaction {
/// Plain list of nodes that has to be appended to the end of the array representation
/// of the tree as the result of append operation.
pub appended: Vec<EntryLink>,
/// New root as a result of the operation (can be generated one).
pub new_root: EntryLink,
}
/// Result of truncating one or severl leaves.
pub struct DeleteTransaction {
/// Number of leaves that should be dropped from the end of the list.
pub truncated: u32,
/// New root as the result of the operation (can be generated one).
pub new_root: EntryLink,
}
impl Tree { impl Tree {
fn resolve_link(&self, link: EntryLink) -> Result<IndexedNode, Error> { fn resolve_link(&self, link: EntryLink) -> Result<IndexedNode, Error> {
match link { match link {
@ -122,6 +104,10 @@ impl Tree {
gen += 1; gen += 1;
} }
for (idx, node) in extra {
result.stored.insert(idx, node);
}
result.root = root; result.root = root;
result result
@ -147,7 +133,9 @@ impl Tree {
} }
/// Append one leaf to the tree. /// Append one leaf to the tree.
pub fn append_leaf(&mut self, new_leaf: NodeData) -> Result<AppendTransaction, Error> { ///
/// Returns links to actual nodes that has to be persisted as the result of the append.
pub fn append_leaf(&mut self, new_leaf: NodeData) -> Result<Vec<EntryLink>, Error> {
let root = self.root; let root = self.root;
let new_leaf_link = self.push(new_leaf.into()); let new_leaf_link = self.push(new_leaf.into());
let mut appended = Vec::new(); let mut appended = Vec::new();
@ -190,10 +178,7 @@ impl Tree {
self.root = new_root; self.root = new_root;
Ok(AppendTransaction { Ok(appended)
new_root,
appended,
})
} }
#[cfg(test)] #[cfg(test)]
@ -214,7 +199,9 @@ impl Tree {
} }
/// Truncate one leaf from the end of the tree. /// Truncate one leaf from the end of the tree.
pub fn truncate_leaf(&mut self) -> Result<DeleteTransaction, Error> { ///
/// Returns actual number of nodes that has to be removed from the array representation.
pub fn truncate_leaf(&mut self) -> Result<u32, Error> {
let root = { let root = {
let (leaves, root_left_child) = { let (leaves, root_left_child) = {
let n = self.resolve_link(self.root)?; let n = self.resolve_link(self.root)?;
@ -226,10 +213,7 @@ impl Tree {
if leaves & 1 != 0 { if leaves & 1 != 0 {
self.pop(); self.pop();
self.root = root_left_child; self.root = root_left_child;
return Ok(DeleteTransaction { return Ok(1);
truncated: 1,
new_root: root_left_child,
})
} else { } else {
self.resolve_link(self.root)? self.resolve_link(self.root)?
} }
@ -266,10 +250,7 @@ impl Tree {
self.root = new_root; self.root = new_root;
Ok(DeleteTransaction { Ok(truncated)
new_root,
truncated,
})
} }
/// Length of array representation of the tree. /// Length of array representation of the tree.
@ -277,11 +258,17 @@ impl Tree {
self.stored_count self.stored_count
} }
/// Link to the root node
pub fn root(&self) -> EntryLink { self.root } pub fn root(&self) -> EntryLink { self.root }
/// Reference to the root ndoe
pub fn root_node(&self) -> Result<IndexedNode, Error> {
self.resolve_link(self.root)
}
} }
struct IndexedNode<'a> { pub struct IndexedNode<'a> {
node: &'a Entry, node: &'a Entry,
link: EntryLink, link: EntryLink,
} }
@ -296,6 +283,10 @@ impl<'a> IndexedNode<'a> {
self.node.right().map_err(|e| e.augment(self.link)) self.node.right().map_err(|e| e.augment(self.link))
} }
pub fn node(&self) -> &Entry {
self.node
}
} }
fn combine_nodes<'a>(left: IndexedNode<'a>, right: IndexedNode<'a>) -> Entry { fn combine_nodes<'a>(left: IndexedNode<'a>, right: IndexedNode<'a>) -> Entry {
@ -345,7 +336,7 @@ mod tests {
} }
} }
fn initial() -> (EntryLink, Tree) { fn initial() -> Tree {
let node1: Entry = leaf(1).into(); let node1: Entry = leaf(1).into();
let node2: Entry = leaf(2).into(); let node2: Entry = leaf(2).into();
@ -354,33 +345,29 @@ mod tests {
kind: EntryKind::Leaf, kind: EntryKind::Leaf,
}; };
(EntryLink::Stored(2), Tree::populate(vec![node1, node2, node3], EntryLink::Stored(2))) Tree::populate(vec![node1, node2, node3], EntryLink::Stored(2))
} }
// returns tree with specified number of leafs and it's root // returns tree with specified number of leafs and it's root
fn generated(length: u32) -> (Tree, EntryLink) { fn generated(length: u32) -> Tree {
assert!(length >= 3); assert!(length >= 3);
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 2..length { for i in 2..length {
root = tree tree.append_leaf(leaf(i+1).into()).expect("Failed to append");
.append_leaf(leaf(i+1).into())
.expect("Failed to append")
.new_root;
} }
(tree, root) tree
} }
#[test] #[test]
fn discrete_append() { fn discrete_append() {
let (root, mut tree) = initial(); let mut tree = initial();
// ** APPEND 3 ** // ** APPEND 3 **
let append_tx = tree let appended = tree
.append_leaf(leaf(3)) .append_leaf(leaf(3))
.expect("Failed to append"); .expect("Failed to append");
let new_root_link = append_tx.new_root; let new_root = tree.root_node().expect("Failed to resolve root").node;
let new_root = tree.resolve_link(new_root_link).expect("Failed to resolve root").node;
// initial tree: (2) // initial tree: (2)
// / \ // / \
@ -396,15 +383,14 @@ mod tests {
// so only (3) is added as real leaf // so only (3) is added as real leaf
// while new root, (4g) is generated one // while new root, (4g) is generated one
assert_eq!(new_root.data.end_height, 3); assert_eq!(new_root.data.end_height, 3);
assert_eq!(append_tx.appended.len(), 1); assert_eq!(appended.len(), 1);
// ** APPEND 4 ** // ** APPEND 4 **
let append_tx = tree let appended = tree
.append_leaf(leaf(4)) .append_leaf(leaf(4))
.expect("Failed to append"); .expect("Failed to append");
let new_root_link = append_tx.new_root; let new_root = tree.root_node().expect("Failed to resolve root").node;
let new_root = tree.resolve_link(new_root_link).expect("Failed to resolve root").node;
// intermediate tree: // intermediate tree:
// (4g) // (4g)
@ -423,16 +409,15 @@ mod tests {
// so (4), (5), (6) are added as real leaves // so (4), (5), (6) are added as real leaves
// and new root, (6) is stored one // and new root, (6) is stored one
assert_eq!(new_root.data.end_height, 4); assert_eq!(new_root.data.end_height, 4);
assert_eq!(append_tx.appended.len(), 3); assert_eq!(appended.len(), 3);
assert_matches!(new_root_link, EntryLink::Stored(6)); assert_matches!(tree.root(), EntryLink::Stored(6));
// ** APPEND 5 ** // ** APPEND 5 **
let append_tx = tree let appended = tree
.append_leaf(leaf(5)) .append_leaf(leaf(5))
.expect("Failed to append"); .expect("Failed to append");
let new_root_link = append_tx.new_root; let new_root = tree.root_node().expect("Failed to resolve root").node;
let new_root = tree.resolve_link(new_root_link).expect("Failed to resolve root").node;
// intermediate tree: // intermediate tree:
// ( 6 ) // ( 6 )
@ -453,19 +438,18 @@ mod tests {
// so (7) is added as real leaf // so (7) is added as real leaf
// and new root, (8g) is generated one // and new root, (8g) is generated one
assert_eq!(new_root.data.end_height, 5); assert_eq!(new_root.data.end_height, 5);
assert_eq!(append_tx.appended.len(), 1); assert_eq!(appended.len(), 1);
assert_matches!(new_root_link, EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
tree.for_children(new_root_link, |l, r| { tree.for_children(tree.root(), |l, r| {
assert_matches!(l, EntryLink::Stored(6)); assert_matches!(l, EntryLink::Stored(6));
assert_matches!(r, EntryLink::Stored(7)); assert_matches!(r, EntryLink::Stored(7));
}); });
// *** APPEND #6 *** // *** APPEND #6 ***
let append_tx = tree let appended = tree
.append_leaf(leaf(6)) .append_leaf(leaf(6))
.expect("Failed to append"); .expect("Failed to append");
let new_root_link = append_tx.new_root; let new_root = tree.root_node().expect("Failed to resolve root").node;
let new_root = tree.resolve_link(new_root_link).expect("Failed to resolve root").node;
// intermediate tree: // intermediate tree:
// ( 8g ) // ( 8g )
@ -488,21 +472,20 @@ mod tests {
// so (7) is added as real leaf // so (7) is added as real leaf
// and new root, (8g) is generated one // and new root, (8g) is generated one
assert_eq!(new_root.data.end_height, 6); assert_eq!(new_root.data.end_height, 6);
assert_eq!(append_tx.appended.len(), 2); assert_eq!(appended.len(), 2);
assert_matches!(new_root_link, EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
tree.for_children(new_root_link, |l, r| { tree.for_children(tree.root(), |l, r| {
assert_matches!(l, EntryLink::Stored(6)); assert_matches!(l, EntryLink::Stored(6));
assert_matches!(r, EntryLink::Stored(9)); assert_matches!(r, EntryLink::Stored(9));
}); });
// *** APPEND #7 *** // *** APPEND #7 ***
let append_tx = tree let appended = tree
.append_leaf(leaf(7)) .append_leaf(leaf(7))
.expect("Failed to append"); .expect("Failed to append");
let new_root_link = append_tx.new_root;
let new_root = tree let new_root = tree
.resolve_link(new_root_link) .root_node()
.expect("Failed to resolve root") .expect("Failed to resolve root")
.node; .node;
@ -529,9 +512,9 @@ mod tests {
// so (7) is added as real leaf // so (7) is added as real leaf
// and new root, (8g) is generated one // and new root, (8g) is generated one
assert_eq!(new_root.data.end_height, 7); assert_eq!(new_root.data.end_height, 7);
assert_eq!(append_tx.appended.len(), 1); assert_eq!(appended.len(), 1);
assert_matches!(new_root_link, EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
tree.for_children(new_root_link, |l, r| { tree.for_children(tree.root(), |l, r| {
assert_matches!(l, EntryLink::Generated(_)); assert_matches!(l, EntryLink::Generated(_));
assert_matches!(r, EntryLink::Stored(10)); assert_matches!(r, EntryLink::Stored(10));
}); });
@ -539,10 +522,8 @@ mod tests {
#[test] #[test]
fn truncate_simple() { fn truncate_simple() {
let (mut tree, root) = generated(9); let mut tree = generated(9);
let delete_tx = tree tree.truncate_leaf().expect("Failed to truncate");
.truncate_leaf()
.expect("Failed to truncate");
// initial tree: // initial tree:
// //
@ -568,16 +549,14 @@ mod tests {
// so (15) is truncated // so (15) is truncated
// and new root, (14) is a stored one now // and new root, (14) is a stored one now
assert_matches!(delete_tx.new_root, EntryLink::Stored(14)); assert_matches!(tree.root(), EntryLink::Stored(14));
assert_eq!(tree.len(), 15); assert_eq!(tree.len(), 15);
} }
#[test] #[test]
fn truncate_generated() { fn truncate_generated() {
let (mut tree, root) = generated(10); let mut tree = generated(10);
let delete_tx = tree let deleted = tree.truncate_leaf().expect("Failed to truncate");
.truncate_leaf()
.expect("Failed to truncate");
// initial tree: // initial tree:
// //
@ -604,11 +583,11 @@ mod tests {
// new root is generated // new root is generated
assert_matches!(delete_tx.new_root, EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
// left is 14 and right is 15 // left is 14 and right is 15
let (left_root_child, right_root_child) = { let (left_root_child, right_root_child) = {
let root = tree.resolve_link(delete_tx.new_root).expect("Failed to resolve"); let root = tree.root_node().expect("Failed to resolve");
( (
root.left().expect("Expected node"), root.left().expect("Expected node"),
@ -622,21 +601,18 @@ mod tests {
); );
// two stored nodes should leave us (leaf 16 and no longer needed node 17) // two stored nodes should leave us (leaf 16 and no longer needed node 17)
assert_eq!(delete_tx.truncated, 2); assert_eq!(deleted, 2);
assert_eq!(tree.len(), 16); assert_eq!(tree.len(), 16);
} }
#[test] #[test]
fn tree_len() { fn tree_len() {
let (mut root, mut tree) = initial(); let mut tree = initial();
assert_eq!(tree.len(), 3); assert_eq!(tree.len(), 3);
for i in 0..2 { for i in 0..2 {
root = tree tree.append_leaf(leaf(i+3)).expect("Failed to append");
.append_leaf(leaf(i+3))
.expect("Failed to append")
.new_root;
} }
assert_eq!(tree.len(), 7); assert_eq!(tree.len(), 7);
@ -647,23 +623,17 @@ mod tests {
#[test] #[test]
fn tree_len_long() { fn tree_len_long() {
let (mut root, mut tree) = initial(); let mut tree = initial();
assert_eq!(tree.len(), 3); assert_eq!(tree.len(), 3);
for i in 0..4094 { for i in 0..4094 {
root = tree tree.append_leaf(leaf(i+3)).expect("Failed to append");
.append_leaf(leaf(i+3))
.expect("Failed to append")
.new_root;
} }
assert_eq!(tree.len(), 8191); // 4096*2-1 (full tree) assert_eq!(tree.len(), 8191); // 4096*2-1 (full tree)
for _ in 0..2049 { for _ in 0..2049 {
root = tree tree.truncate_leaf().expect("Failed to truncate");
.truncate_leaf()
.expect("Failed to truncate")
.new_root;
} }
assert_eq!(tree.len(), 4083); // 4095 - log2(4096) assert_eq!(tree.len(), 4083); // 4095 - log2(4096)
@ -675,18 +645,15 @@ mod tests {
if number > 1024*1024 { if number > 1024*1024 {
TestResult::discard() TestResult::discard()
} else { } else {
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 0..number { for i in 0..number {
root = tree tree.append_leaf(leaf(i+3)).expect("Failed to append");
.append_leaf(leaf(i+3))
.expect("Failed to append")
.new_root;
} }
for _ in 0..number { for _ in 0..number {
root = tree.truncate_leaf().expect("Failed to truncate").new_root; tree.truncate_leaf().expect("Failed to truncate");
} }
TestResult::from_bool(if let EntryLink::Stored(2) = root { true } else { false }) TestResult::from_bool(if let EntryLink::Stored(2) = tree.root() { true } else { false })
} }
} }
@ -694,22 +661,13 @@ mod tests {
if number > 1024 * 1024 || number < 3 { if number > 1024 * 1024 || number < 3 {
TestResult::discard() TestResult::discard()
} else { } else {
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 1..(number-1) { for i in 1..(number-1) {
root = tree tree.append_leaf(leaf(i+2)).expect("Failed to append");
.append_leaf(leaf(i+2))
.expect("Failed to append")
.new_root;
} }
TestResult::from_bool( TestResult::from_bool(
tree tree.root_node().expect("no root").node.leaf_count() == number as u64
.resolve_link(root)
.expect("Failed to resolve root")
.node
.leaf_count()
==
number as u64
) )
} }
} }
@ -718,17 +676,17 @@ mod tests {
if number > 2048 * 2048 || number < 3 { if number > 2048 * 2048 || number < 3 {
TestResult::discard() TestResult::discard()
} else { } else {
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 1..(number-1) { for i in 1..(number-1) {
root = tree.append_leaf(leaf(i+2)).expect("Failed to append").new_root; tree.append_leaf(leaf(i+2)).expect("Failed to append");
} }
TestResult::from_bool( TestResult::from_bool(
if number & number - 1 == 0 { if number & number - 1 == 0 {
if let EntryLink::Stored(_) = root { true } if let EntryLink::Stored(_) = tree.root() { true }
else { false } else { false }
} else { } else {
if let EntryLink::Generated(_) = root { true } if let EntryLink::Generated(_) = tree.root() { true }
else { false } else { false }
} }
) )
@ -741,22 +699,22 @@ mod tests {
if add > 2048 * 2048 || add < delete { if add > 2048 * 2048 || add < delete {
TestResult::discard() TestResult::discard()
} else { } else {
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 0..add { for i in 0..add {
root = tree.append_leaf(leaf(i+3)).expect("Failed to append").new_root; tree.append_leaf(leaf(i+3)).expect("Failed to append");
} }
for _ in 0..delete { for _ in 0..delete {
root = tree.truncate_leaf().expect("Failed to truncate").new_root; tree.truncate_leaf().expect("Failed to truncate");
} }
let total = add - delete + 2; let total = add - delete + 2;
TestResult::from_bool( TestResult::from_bool(
if total & total - 1 == 0 { if total & total - 1 == 0 {
if let EntryLink::Stored(_) = root { true } if let EntryLink::Stored(_) = tree.root() { true }
else { false } else { false }
} else { } else {
if let EntryLink::Generated(_) = root { true } if let EntryLink::Generated(_) = tree.root() { true }
else { false } else { false }
} }
) )
@ -768,12 +726,12 @@ mod tests {
if add > 2048 * 2048 || add < delete { if add > 2048 * 2048 || add < delete {
TestResult::discard() TestResult::discard()
} else { } else {
let (mut root, mut tree) = initial(); let mut tree = initial();
for i in 0..add { for i in 0..add {
root = tree.append_leaf(leaf(i+3)).expect("Failed to append").new_root; tree.append_leaf(leaf(i+3)).expect("Failed to append");
} }
for _ in 0..delete { for _ in 0..delete {
root = tree.truncate_leaf().expect("Failed to truncate").new_root; tree.truncate_leaf().expect("Failed to truncate");
} }
let total = add - delete + 2; let total = add - delete + 2;