From 1cd1fe281b039c30b5bb6bfd93f6b83b2fcceb24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kevin=20Ka=C3=9Felmann?= <kevin.kasselmann@arithnea.de>
Date: Fri, 29 Jun 2018 10:01:53 +0200
Subject: [PATCH] [Labels] Added Generics
---
src/common/errors.rs | 4 +
src/common/succinct_tree.rs | 6 +-
src/trees/bp_tree.rs | 115 +++++++++++++++-----------
src/trees/louds_tree.rs | 121 ++++++++++++++++------------
testdata/loudstree_invalid.testdata | Bin 0 -> 115 bytes
5 files changed, 147 insertions(+), 99 deletions(-)
create mode 100644 testdata/loudstree_invalid.testdata
diff --git a/src/common/errors.rs b/src/common/errors.rs
index cc288b9..44bc7fd 100644
--- a/src/common/errors.rs
+++ b/src/common/errors.rs
@@ -26,4 +26,8 @@ pub enum NodeError {
HasNoParentError,
#[fail(display = "The supplied index does not reference a node with a next sibling.")]
HasNoFurtherSiblingsError,
+ #[fail(display = "The supplied index has no label.")]
+ NoLabelError,
+ #[fail(display = "There is no child which passes the requirements.")]
+ NoSuchChildError,
}
diff --git a/src/common/succinct_tree.rs b/src/common/succinct_tree.rs
index 88116f1..74cd871 100644
--- a/src/common/succinct_tree.rs
+++ b/src/common/succinct_tree.rs
@@ -4,14 +4,16 @@ use common::errors::NodeError;
use id_tree::Tree;
use std::fmt::Debug;
-pub trait SuccinctTree<T>: Debug {
+pub trait SuccinctTree<T, Label>: Debug {
fn is_leaf(&self, index: u64) -> Result<bool, NodeError>;
fn parent(&self, index: u64) -> Result<u64, NodeError>;
fn first_child(&self, index: u64) -> Result<u64, NodeError>;
fn next_sibling(&self, index: u64) -> Result<u64, NodeError>;
fn from_id_tree(tree: Tree<i32>) -> Result<T, EmptyTreeError>;
+ fn child_label(&self, index: u64) -> Result<Label, NodeError>;
+ fn labeled_child(&self, index: u64, label: Label) -> Result<u64, NodeError>;
- /// Prüft ob ein Bitvector ein gültiger SuccinctTree ist, anhand des gültige Exzesses und
+ /// Prüft ob ein Bitvector ein gültiger SuccinctTree ist, anhand des gültigen Exzesses und
/// der Anzahl öffnender und schließender Klammern
///
/// # Arguments
diff --git a/src/trees/bp_tree.rs b/src/trees/bp_tree.rs
index 6f49d24..3621c4f 100644
--- a/src/trees/bp_tree.rs
+++ b/src/trees/bp_tree.rs
@@ -45,20 +45,19 @@ use std::fs;
use std::fs::File;
use std::io::Write;
-#[derive(Serialize, Deserialize)]
-pub struct BPTree {
- bits: BitVec<u8>,
+pub struct BPTree<L> {
+ labels: Vec<L>,
rankselect: RankSelect,
minmax: MinMax,
}
-impl PartialEq for BPTree {
+impl<L> PartialEq for BPTree<L> {
fn eq(&self, other: &Self) -> bool {
- self.bits == other.bits
+ self.rankselect.bits() == other.rankselect.bits()
}
}
-impl SuccinctTree<BPTree> for BPTree {
+impl<L> SuccinctTree<BPTree<L>, L> for BPTree<L> {
/// Checks if a node is a leaf.
/// # Arguments
/// * `index` The index of the node to check
@@ -66,7 +65,7 @@ impl SuccinctTree<BPTree> for BPTree {
/// * `NotANodeError` If `index` does not reference a node.
fn is_leaf(&self, index: u64) -> Result<bool, NodeError> {
self.is_valid_index(index)?;
- Ok(!self.bits.get_bit(index + 1))
+ Ok(!self.rankselect.bits().get_bit(index + 1))
}
/// Returns the index of the parent of this node
@@ -131,25 +130,44 @@ impl SuccinctTree<BPTree> for BPTree {
Ok(Self {
rankselect: RankSelect::new(bitvec.clone(), superblock_size as usize),
minmax: MinMax::new(bitvec.clone(), 1024),
- bits: bitvec,
+ labels: Vec::with_capacity(bitvec.len() as usize),
})
}
+
+ /// Returns the label for the edge between the parent and the node
+ /// # Arguments
+ /// * `index` The index of the node to get the label of
+ /// # Errors
+ /// * `NotANodeError` If `index` does not reference a node.
+ fn child_label(&self, index: u64) -> Result<L, NodeError> {
+ unimplemented!();
+ }
+
+ /// Returns the child from the specified node with that label
+ /// # Arguments
+ /// * `index` The index of the node to analyze
+ /// * `label` The label which a should have
+ /// # Errors
+ /// * `NoSuchChildError` If there is no child which has this label
+ fn labeled_child(&self, index: u64, label: L) -> Result<u64, NodeError> {
+ unimplemented!();
+ }
}
-impl Debug for BPTree {
+impl<L> Debug for BPTree<L> {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
- write!(f, "BPTree\n {{ bits: {:?} }}", self.bits)
+ write!(f, "BPTree\n {{ bits: {:?} }}", self.rankselect.bits())
}
}
-impl BPTree {
+impl<L> BPTree<L> {
/// Returns whether the index is valid
/// # Arguments
/// * `index` The index which should be valid
/// # Errors
/// * `NotANodeError` If `index` does not reference a node.
pub fn is_valid_index(&self, index: u64) -> Result<bool, NodeError> {
- if index >= self.bits.len() {
+ if index >= self.rankselect.bits().len() {
Err(NodeError::NotANodeError)
} else {
Ok(true)
@@ -214,9 +232,9 @@ impl BPTree {
}
let superblock_size = Self::calc_superblock_size(bitvec.len());
Ok(Self {
- rankselect: RankSelect::new(bitvec.clone(), superblock_size as usize),
minmax: MinMax::new(bitvec.clone(), 1024),
- bits: bitvec,
+ labels: Vec::with_capacity(bitvec.len() as usize),
+ rankselect: RankSelect::new(bitvec, superblock_size as usize),
})
}
@@ -226,8 +244,12 @@ impl BPTree {
///
pub fn from_file(path: String) -> Result<Self, Error> {
let file = fs::read(path).context("Could not read saved tree.")?;
- let tree: Self = deserialize(&file).context("Error while deserializing tree.")?;
- Ok(tree)
+ let rankselect: RankSelect = deserialize(&file).context("Error while deserializing tree.")?;
+ Ok(Self {
+ minmax: MinMax::new(rankselect.bits().clone(), 1024),
+ labels: Vec::with_capacity(rankselect.bits().len() as usize),
+ rankselect: rankselect,
+ })
}
/// Serializes a BPTree to a file
@@ -235,7 +257,7 @@ impl BPTree {
/// * `path` The path of the file to save to. Will be overwritten if it exists.
///
pub fn save_to(&self, path: String) -> Result<(), Error> {
- let encoded = serialize(&self).context("Error while serializing tree.")?;
+ let encoded = serialize(&self.rankselect).context("Error while serializing tree.")?;
let mut file = File::create(path).context("Could not save tree.")?;
file.write_all(&encoded)?;
Ok(())
@@ -265,9 +287,10 @@ mod tests {
#[test]
fn new_from_bitvec() {
let bitvec = bit_vec!(true, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(
- tree.bits, bitvec,
+ tree.rankselect.bits().clone(),
+ bitvec,
"BPTree seems to somehow change the bitvector it was created with."
);
}
@@ -275,19 +298,17 @@ mod tests {
#[test]
fn new_from_bitvec_invalid() {
let bitvec = bit_vec!(false, false);
- assert_eq!(
- BPTree::from_bitvec(bitvec.clone()).unwrap_err(),
- InvalidBitvecError
- );
+ let tree: Result<BPTree<String>, InvalidBitvecError> = BPTree::from_bitvec(bitvec.clone());
+ assert_eq!(tree.unwrap_err(), InvalidBitvecError);
}
#[test]
fn save_load() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
- tree.save_to("testdata/bptree.testdata".to_string())
- .unwrap();
- let result = BPTree::from_file("testdata/bptree.testdata".to_string()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let path = "testdata/bptree.testdata";
+ tree.save_to(path.to_string()).unwrap();
+ let result = BPTree::from_file(path.to_string()).unwrap();
assert_eq!(
tree, result,
"The loaded tree is not equal to the original one."
@@ -297,27 +318,28 @@ mod tests {
#[test]
#[should_panic(expected = "Error while deserializing tree.")]
fn load_invalid() {
- BPTree::from_file("testdata/bptree_invalid.testdata".to_string()).unwrap();
+ let _tree: BPTree<String> =
+ BPTree::from_file("testdata/bptree_invalid.testdata".to_string()).unwrap();
}
#[test]
fn is_leaf() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert!(tree.is_leaf(1).unwrap());
}
#[test]
fn is_no_leaf() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert!(!tree.is_leaf(0).unwrap());
}
#[test]
fn is_leaf_wrong_index() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.is_leaf(4).unwrap_err(), NodeError::NotANodeError);
}
@@ -325,28 +347,28 @@ mod tests {
#[ignore]
fn parent() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.parent(1).unwrap(), 0);
}
#[test]
fn parent_no_parent() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.parent(0).unwrap_err(), NodeError::HasNoParentError);
}
#[test]
fn first_child() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.first_child(0).unwrap(), 1);
}
#[test]
fn first_child_no_parent() {
let bitvec = bit_vec!(true, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.first_child(1).unwrap_err(), NodeError::NotAParentError);
}
@@ -354,7 +376,7 @@ mod tests {
#[ignore]
fn next_sibling() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.next_sibling(1).unwrap(), 3);
}
@@ -362,7 +384,7 @@ mod tests {
#[ignore]
fn next_sibling_no_next_sibling() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(
tree.next_sibling(3).unwrap_err(),
NodeError::HasNoFurtherSiblingsError
@@ -372,7 +394,7 @@ mod tests {
#[test]
fn pre_rank() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.pre_rank(1).unwrap(), 2);
assert_eq!(tree.pre_rank(2).unwrap(), 2);
assert_eq!(tree.pre_rank(3).unwrap(), 3);
@@ -383,7 +405,7 @@ mod tests {
#[test]
fn pre_select() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.pre_select(1).unwrap(), 0);
assert_eq!(tree.pre_select(2).unwrap(), 1);
assert_eq!(tree.pre_select(3).unwrap(), 3);
@@ -394,7 +416,7 @@ mod tests {
#[test]
fn ancestor_is_ancestor() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert!(tree.ancestor(0, 1).unwrap());
assert!(tree.ancestor(0, 3).unwrap());
}
@@ -402,7 +424,7 @@ mod tests {
#[test]
fn ancestor_not_a_ancestor() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert!(!tree.ancestor(1, 3).unwrap());
assert!(!tree.ancestor(1, 0).unwrap());
}
@@ -410,7 +432,7 @@ mod tests {
#[test]
fn depth() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.depth(0).unwrap(), 1);
assert_eq!(tree.depth(1).unwrap(), 2);
assert_eq!(tree.depth(3).unwrap(), 2);
@@ -419,7 +441,7 @@ mod tests {
#[test]
fn subtree_size() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.subtree_size(0).unwrap(), 3);
assert_eq!(tree.subtree_size(1).unwrap(), 1);
assert_eq!(tree.subtree_size(3).unwrap(), 1);
@@ -428,7 +450,7 @@ mod tests {
#[test]
fn traverse_id_tree_for_bitvec() {
let bitvec = bit_vec!(true, true, true, false, false, true, false, false);
- let expected_tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let expected_tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
let mut id_tree: Tree<i32> = TreeBuilder::new().with_node_capacity(5).build();
let root_id: NodeId = id_tree.insert(Node::new(0), AsRoot).unwrap();
let child_id = id_tree.insert(Node::new(1), UnderNode(&root_id)).unwrap();
@@ -441,13 +463,14 @@ mod tests {
#[test]
fn from_empty_id_tree() {
let id_tree: Tree<i32> = TreeBuilder::new().with_node_capacity(5).build();
- assert_eq!(BPTree::from_id_tree(id_tree).unwrap_err(), EmptyTreeError)
+ let bp_tree: Result<BPTree<String>, EmptyTreeError> = BPTree::from_id_tree(id_tree);
+ assert_eq!(bp_tree.unwrap_err(), EmptyTreeError);
}
#[test]
fn print() {
let bitvec = bit_vec!(true, true, false, true, false, false);
- let tree = BPTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: BPTree<String> = BPTree::from_bitvec(bitvec.clone()).unwrap();
let str = format!("{:?}", tree);
assert_eq!(
str,
diff --git a/src/trees/louds_tree.rs b/src/trees/louds_tree.rs
index ae46913..bf6ed55 100644
--- a/src/trees/louds_tree.rs
+++ b/src/trees/louds_tree.rs
@@ -36,25 +36,26 @@ use std::fmt::{Debug, Formatter};
use std::fs;
use std::fs::File;
use std::io::Write;
+use std::vec::Vec;
-#[derive(Serialize, Deserialize)]
-pub struct LOUDSTree {
+pub struct LOUDSTree<L> {
rankselect: RankSelect,
+ labels: Vec<L>,
}
-impl PartialEq for LOUDSTree {
+impl<L> PartialEq for LOUDSTree<L> {
fn eq(&self, other: &Self) -> bool {
self.rankselect.bits() == other.rankselect.bits()
}
}
-impl Debug for LOUDSTree {
+impl<L> Debug for LOUDSTree<L> {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
write!(f, "LOUDSTree\n {{ bits: {:?} }}", self.rankselect.bits())
}
}
-impl SuccinctTree<LOUDSTree> for LOUDSTree {
+impl<L> SuccinctTree<LOUDSTree<L>, L> for LOUDSTree<L> {
/// Checks if a node is a leaf.
/// # Arguments
/// * `index` The index of the node to check
@@ -146,9 +147,22 @@ impl SuccinctTree<LOUDSTree> for LOUDSTree {
}
Ok(Self::from_bitvec(bitvec).unwrap())
}
+
+ /// Returns the label for the edge between the parent and the node
+ /// # Arguments
+ /// * `index` The index of the node to get the label of
+ /// # Errors
+ /// * `NotANodeError` If `index` does not reference a node.
+ fn child_label(&self, index: u64) -> Result<L, NodeError> {
+ unimplemented!();
+ }
+
+ fn labeled_child(&self, index: u64, label: L) -> Result<u64, NodeError> {
+ unimplemented!();
+ }
}
-impl LOUDSTree {
+impl<L> LOUDSTree<L> {
fn prev_0(&self, index: u64) -> Option<u64> {
self.rankselect.select_0(self.rankselect.rank_0(index)?)
}
@@ -183,18 +197,22 @@ impl LOUDSTree {
}
let superblock_size = Self::calc_superblock_size(bitvec.len());
Ok(Self {
- rankselect: RankSelect::new(bitvec.clone(), superblock_size as usize),
+ labels: Vec::with_capacity(bitvec.len() as usize),
+ rankselect: RankSelect::new(bitvec, superblock_size as usize),
})
}
pub fn from_file(path: String) -> Result<Self, Error> {
let file = fs::read(path).context("Could not read saved tree.")?;
- let tree: Self = deserialize(&file).context("Error while deserializing tree.")?;
- Ok(tree)
+ let rankselect: RankSelect = deserialize(&file).context("Error while deserializing tree.")?;
+ Ok(Self {
+ labels: Vec::with_capacity(rankselect.bits().len() as usize),
+ rankselect: rankselect,
+ })
}
pub fn save_to(&self, path: String) -> Result<(), Error> {
- let encoded = serialize(&self).context("Error while serializing tree.")?;
+ let encoded = serialize(&self.rankselect).context("Error while serializing tree.")?;
let mut file = File::create(path).context("Could not save tree.")?;
file.write_all(&encoded)?;
Ok(())
@@ -210,7 +228,7 @@ mod tests {
#[test]
fn new_from_bitvec() {
let bitvec = bit_vec![true, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(
*tree.rankselect.bits(),
bitvec,
@@ -221,72 +239,91 @@ mod tests {
#[test]
fn new_from_bitvec_invalid() {
let bitvec = bit_vec![true, true];
+ let tree: Result<LOUDSTree<String>, InvalidBitvecError> = LOUDSTree::from_bitvec(bitvec);
+ assert_eq!(tree.unwrap_err(), InvalidBitvecError);
+ }
+
+ #[test]
+ fn save_load() {
+ let bitvec =
+ bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ tree.save_to("testdata/loudstree.testdata".to_string())
+ .unwrap();
+ let result: LOUDSTree<String> = LOUDSTree::from_file("testdata/loudstree.testdata".to_string()).unwrap();
assert_eq!(
- LOUDSTree::from_bitvec(bitvec.clone()).unwrap_err(),
- InvalidBitvecError
+ tree, result,
+ "The loaded tree is not equal to the original one."
);
}
+ #[test]
+ #[should_panic(expected = "Error while deserializing tree.")]
+ fn load_invalid() {
+ let _tree: LOUDSTree<String> =
+ LOUDSTree::from_file("testdata/loudstree_invalid.testdata".to_string()).unwrap();
+ }
+
#[test]
fn is_leaf() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert!(tree.is_leaf(3).unwrap());
}
#[test]
fn is_no_leaf() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert!(!tree.is_leaf(1).unwrap());
}
#[test]
fn is_leaf_wrong_index() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.is_leaf(2).unwrap_err(), NodeError::NotANodeError);
}
#[test]
fn is_leaf_wrong_index2() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.is_leaf(4).unwrap_err(), NodeError::NotANodeError);
}
#[test]
fn first_child() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.first_child(1).unwrap(), 3);
}
#[test]
fn first_child_no_parent() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.first_child(3).unwrap_err(), NodeError::NotAParentError);
}
#[test]
fn parent() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.parent(3).unwrap(), 1)
}
#[test]
fn parent_root_node() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.parent(1).unwrap_err(), NodeError::RootNodeError)
}
#[test]
fn parent_no_node() {
let bitvec = bit_vec![true, true, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.parent(0).unwrap_err(), NodeError::NotANodeError)
}
@@ -294,7 +331,7 @@ mod tests {
fn next_sibling() {
let bitvec =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.next_sibling(5).unwrap(), 7);
assert_eq!(tree.next_sibling(7).unwrap(), 9);
}
@@ -303,7 +340,7 @@ mod tests {
fn no_next_sibling() {
let bitvec =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(
tree.next_sibling(10).unwrap_err(),
NodeError::NoSiblingError
@@ -314,7 +351,7 @@ mod tests {
fn degree() {
let bitvec =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.degree(1).unwrap(), 3);
assert_eq!(tree.degree(5).unwrap(), 1);
assert_eq!(tree.degree(9).unwrap(), 0);
@@ -324,7 +361,7 @@ mod tests {
fn child_rank() {
let bitvec =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
assert_eq!(tree.child_rank(9).unwrap(), 2);
assert_eq!(tree.child_rank(7).unwrap(), 1);
assert_eq!(tree.child_rank(5).unwrap(), 0);
@@ -334,7 +371,7 @@ mod tests {
fn print() {
let bitvec =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
let str = format!("{:?}", tree);
assert_eq!(str, "LOUDSTree\n { bits: bit_vec![true, true, true, true, false, true, false, true, false, false, false, false] }")
}
@@ -344,32 +381,13 @@ mod tests {
let bitvec_a =
bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
let bitvec_b = bit_vec![true, true, false, false];
- let tree_a = LOUDSTree::from_bitvec(bitvec_a.clone()).unwrap();
- let tree_b = LOUDSTree::from_bitvec(bitvec_a.clone()).unwrap();
- let tree_c = LOUDSTree::from_bitvec(bitvec_b.clone()).unwrap();
+ let tree_a: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec_a.clone()).unwrap();
+ let tree_b: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec_a.clone()).unwrap();
+ let tree_c: LOUDSTree<String> = LOUDSTree::from_bitvec(bitvec_b.clone()).unwrap();
assert_eq!(tree_a, tree_b);
assert_ne!(tree_a, tree_c)
}
- #[test]
- fn save_load() {
- let bitvec =
- bit_vec![true, true, true, true, false, true, false, true, false, false, false, false];
- let tree = LOUDSTree::from_bitvec(bitvec.clone()).unwrap();
- tree.save_to("testdata/loudstree.testdata".to_string())
- .unwrap();
- let result = LOUDSTree::from_file("testdata/loudstree.testdata".to_string()).unwrap();
- assert_eq!(
- tree, result,
- "The loaded tree is not equal to the original one."
- );
- }
-
- #[test]
- #[should_panic(expected = "Error while deserializing tree.")]
- fn load_invalid() {
- LOUDSTree::from_file("testdata/bptree_invalid.testdata".to_string()).unwrap();
- }
#[test]
fn from_id_tree() {
@@ -378,7 +396,7 @@ mod tests {
let child_id = id_tree.insert(Node::new(1), UnderNode(&root_id)).unwrap();
id_tree.insert(Node::new(2), UnderNode(&root_id)).unwrap();
id_tree.insert(Node::new(3), UnderNode(&child_id)).unwrap();
- let tree = LOUDSTree::from_id_tree(id_tree).unwrap();
+ let tree: LOUDSTree<String> = LOUDSTree::from_id_tree(id_tree).unwrap();
let bitvec = bit_vec![true, true, true, false, true, false, false, false];
let other_tree = LOUDSTree::from_bitvec(bitvec).unwrap();
assert_eq!(tree, other_tree)
@@ -387,8 +405,9 @@ mod tests {
#[test]
fn from_empty_id_tree() {
let id_tree: Tree<i32> = TreeBuilder::new().with_node_capacity(5).build();
+ let tree: Result<LOUDSTree<String>, EmptyTreeError> = LOUDSTree::from_id_tree(id_tree);
assert_eq!(
- LOUDSTree::from_id_tree(id_tree).unwrap_err(),
+ tree.unwrap_err(),
EmptyTreeError
);
}
diff --git a/testdata/loudstree_invalid.testdata b/testdata/loudstree_invalid.testdata
new file mode 100644
index 0000000000000000000000000000000000000000..4318da13396d0f974a32b7f727f5bf23ac866417
GIT binary patch
literal 115
zcmZQ#fB`Nj!vRWjKxqXA1_nk31_qcoLI*?~#7`_vDNam*YG9COU|<000`WmQK{PXn
LU|?WK%g+Y@uek)W
literal 0
HcmV?d00001
--
GitLab