1use super::{
  2    super::{int_to_node, MerkleStore, MerkleTree, NodeIndex, PartialMerkleTree},
  3    Rpo256, ValuePath, Vec, Word,
  4};
  5
  6// TEST DATA
  7// ================================================================================================
  8
  9const NODE10: NodeIndex = NodeIndex::new_unchecked(1, 0);
 10const NODE11: NodeIndex = NodeIndex::new_unchecked(1, 1);
 11
 12const NODE20: NodeIndex = NodeIndex::new_unchecked(2, 0);
 13const NODE22: NodeIndex = NodeIndex::new_unchecked(2, 2);
 14const NODE23: NodeIndex = NodeIndex::new_unchecked(2, 3);
 15
 16const NODE32: NodeIndex = NodeIndex::new_unchecked(3, 2);
 17const NODE33: NodeIndex = NodeIndex::new_unchecked(3, 3);
 18
 19const VALUES8: [Word; 8] = [
 20    int_to_node(1),
 21    int_to_node(2),
 22    int_to_node(3),
 23    int_to_node(4),
 24    int_to_node(5),
 25    int_to_node(6),
 26    int_to_node(7),
 27    int_to_node(8),
 28];
 29
 30// TESTS
 31// ================================================================================================
 32
 33// with_paths CONSTRUCTOR TESTS
 34// ------------------------------------------------------------------------------------------------
 35
 36#[test]
 37fn get_root() {
 38    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
 39    let expected_root = mt.root();
 40
 41    let ms = MerkleStore::from(&mt);
 42
 43    let path33 = ms.get_path(expected_root, NODE33).unwrap();
 44
 45    let pmt = PartialMerkleTree::with_paths([(3, path33.value.into(), path33.path)]).unwrap();
 46
 47    assert_eq!(pmt.root(), expected_root.into());
 48}
 49
 50#[test]
 51fn add_and_get_paths() {
 52    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
 53    let expected_root = mt.root();
 54
 55    let ms = MerkleStore::from(&mt);
 56
 57    let expected_path33 = ms.get_path(expected_root, NODE33).unwrap();
 58    let expected_path22 = ms.get_path(expected_root, NODE22).unwrap();
 59
 60    let mut pmt = PartialMerkleTree::new();
 61    pmt.add_path(3, expected_path33.value.into(), expected_path33.path.clone())
 62        .unwrap();
 63    pmt.add_path(2, expected_path22.value.into(), expected_path22.path.clone())
 64        .unwrap();
 65
 66    let path33 = pmt.get_path(NODE33).unwrap();
 67    let path22 = pmt.get_path(NODE22).unwrap();
 68    let actual_root = pmt.root();
 69
 70    assert_eq!(expected_path33.path, path33);
 71    assert_eq!(expected_path22.path, path22);
 72    assert_eq!(expected_root, *actual_root);
 73}
 74
 75#[test]
 76fn get_node() {
 77    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
 78    let expected_root = mt.root();
 79
 80    let ms = MerkleStore::from(&mt);
 81
 82    let path33 = ms.get_path(expected_root, NODE33).unwrap();
 83
 84    let pmt = PartialMerkleTree::with_paths([(3, path33.value.into(), path33.path)]).unwrap();
 85
 86    assert_eq!(ms.get_node(expected_root, NODE32).unwrap(), *pmt.get_node(NODE32).unwrap());
 87    assert_eq!(ms.get_node(expected_root, NODE10).unwrap(), *pmt.get_node(NODE10).unwrap());
 88}
 89
 90#[test]
 91fn update_leaf() {
 92    let mut mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
 93    let root = mt.root();
 94
 95    let ms = MerkleStore::from(&mt);
 96    let path33 = ms.get_path(root, NODE33).unwrap();
 97
 98    let mut pmt = PartialMerkleTree::with_paths([(3, path33.value.into(), path33.path)]).unwrap();
 99
100    let new_value32 = int_to_node(132);
101    mt.update_leaf(2, new_value32).unwrap();
102    let expected_root = mt.root();
103
104    pmt.update_leaf(NODE32, new_value32.into()).unwrap();
105    let actual_root = pmt.root();
106
107    assert_eq!(expected_root, *actual_root);
108
109    let mut new_vals = VALUES8.clone();
110    new_vals[1] = int_to_node(131);
111    new_vals[2] = int_to_node(132);
112    let new_value20 = Rpo256::merge(&[new_vals[0].into(), new_vals[1].into()]);
113    let mt = MerkleTree::new(new_vals.to_vec()).unwrap();
114    let expected_root = mt.root();
115
116    pmt.update_leaf(NODE20, new_value20).unwrap();
117    let actual_root = pmt.root();
118
119    assert_eq!(expected_root, *actual_root);
120}
121
122#[test]
123fn check_leaf_depth() {
124    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
125    let expected_root = mt.root();
126
127    let ms = MerkleStore::from(&mt);
128
129    let path33 = ms.get_path(expected_root, NODE33).unwrap();
130
131    let pmt = PartialMerkleTree::with_paths([(3, path33.value.into(), path33.path)]).unwrap();
132
133    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(4, 1)), 2);
134    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(4, 6)), 3);
135    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(4, 10)), 1);
136
137    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(3, 1)), 2);
138    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(3, 2)), 3);
139    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(3, 5)), 1);
140    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(3, 7)), 1);
141
142    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(2, 0)), 2);
143    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(2, 1)), 0);
144    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(2, 2)), 1);
145    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(2, 3)), 1);
146
147    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(1, 0)), 0);
148    assert_eq!(pmt.get_leaf_depth(NodeIndex::make(1, 1)), 1);
149}
150
151#[test]
152fn get_paths() {
153    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
154    let expected_root = mt.root();
155
156    let ms = MerkleStore::from(&mt);
157
158    let path33 = ms.get_path(expected_root, NODE33).unwrap();
159    let path22 = ms.get_path(expected_root, NODE22).unwrap();
160
161    let mut pmt = PartialMerkleTree::new();
162    pmt.add_path(3, path33.value.into(), path33.path.clone()).unwrap();
163    pmt.add_path(2, path22.value.into(), path22.path.clone()).unwrap();
164
165    let leaves = vec![NODE20, NODE22, NODE23, NODE32, NODE33];
166    let expected_paths: Vec<(NodeIndex, ValuePath)> = leaves
167        .iter()
168        .map(|&leaf| {
169            (
170                leaf,
171                ValuePath {
172                    value: mt.get_node(leaf).unwrap().into(),
173                    path: mt.get_path(leaf).unwrap(),
174                },
175            )
176        })
177        .collect();
178
179    let actual_paths = pmt.paths();
180
181    assert_eq!(expected_paths, actual_paths);
182}
183
184#[test]
185fn leaves() {
186    let mt = MerkleTree::new(VALUES8.to_vec()).unwrap();
187    let expected_root = mt.root();
188
189    let ms = MerkleStore::from(&mt);
190
191    let path33 = ms.get_path(expected_root, NODE33).unwrap();
192    let path22 = ms.get_path(expected_root, NODE22).unwrap();
193
194    let mut pmt = PartialMerkleTree::with_paths([(3, path33.value.into(), path33.path)]).unwrap();
195
196    let value11 = mt.get_node(NODE11).unwrap().into();
197    let value20 = mt.get_node(NODE20).unwrap().into();
198    let value32 = mt.get_node(NODE32).unwrap().into();
199    let value33 = mt.get_node(NODE33).unwrap().into();
200
201    let leaves = vec![(NODE11, value11), (NODE20, value20), (NODE32, value32), (NODE33, value33)];
202
203    let expected_leaves = leaves.iter().map(|&tuple| tuple);
204    assert!(expected_leaves.eq(pmt.leaves()));
205
206    pmt.add_path(2, path22.value.into(), path22.path).unwrap();
207
208    let value20 = mt.get_node(NODE20).unwrap().into();
209    let value22 = mt.get_node(NODE22).unwrap().into();
210    let value23 = mt.get_node(NODE23).unwrap().into();
211    let value32 = mt.get_node(NODE32).unwrap().into();
212    let value33 = mt.get_node(NODE33).unwrap().into();
213
214    let leaves = vec![
215        (NODE20, value20),
216        (NODE22, value22),
217        (NODE23, value23),
218        (NODE32, value32),
219        (NODE33, value33),
220    ];
221
222    let expected_leaves = leaves.iter().map(|&tuple| tuple);
223    assert!(expected_leaves.eq(pmt.leaves()));
224}