@Test
public void testHashInner() {
byte[] val = DUMMY;
byte[] lchildval = hashed(val, 3, 3, 2);
byte[] rchildval = hashed(val, 2, 2);
byte[] fullval = hashed(val, 3, 3, 2, 2, 2);
Range full = new Range(tok(-1), tok(-1));
Range lchild = new Range(tok(-1), tok(4));
Range rchild = new Range(tok(4), tok(-1));
Range invalid = new Range(tok(1), tok(-1));
// (zero,one] (one, two] (two,four] (four, six] (six, zero]
mt.split(tok(4));
mt.split(tok(2));
mt.split(tok(6));
mt.split(tok(1));
assertNull(mt.hash(full));
assertNull(mt.hash(lchild));
assertNull(mt.hash(rchild));
assertNull(mt.hash(invalid));
// validate the range
mt.get(tok(1)).hash(val);
mt.get(tok(2)).hash(val);
mt.get(tok(4)).hash(val);
mt.get(tok(6)).hash(val);
mt.get(tok(-1)).hash(val);
assertHashEquals(fullval, mt.hash(full));
assertHashEquals(lchildval, mt.hash(lchild));
assertHashEquals(rchildval, mt.hash(rchild));
assertNull(mt.hash(invalid));
}
@Test
public void testHashDegenerate() {
TOKEN_SCALE = new BigInteger("32");
byte[] val = DUMMY;
byte[] childfullval = hashed(val, 5, 5, 4);
byte[] fullval = hashed(val, 5, 5, 4, 3, 2, 1);
Range childfull = new Range(tok(-1), tok(4));
Range full = new Range(tok(-1), tok(-1));
Range invalid = new Range(tok(4), tok(-1));
mt = new MerkleTree(partitioner, RECOMMENDED_DEPTH, Integer.MAX_VALUE);
mt.split(tok(16));
mt.split(tok(8));
mt.split(tok(4));
mt.split(tok(2));
mt.split(tok(1));
assertNull(mt.hash(full));
assertNull(mt.hash(childfull));
assertNull(mt.hash(invalid));
// validate the range
mt.get(tok(1)).hash(val);
mt.get(tok(2)).hash(val);
mt.get(tok(4)).hash(val);
mt.get(tok(8)).hash(val);
mt.get(tok(16)).hash(val);
mt.get(tok(-1)).hash(val);
assertHashEquals(fullval, mt.hash(full));
assertHashEquals(childfullval, mt.hash(childfull));
assertNull(mt.hash(invalid));
}
@Test
public void testHashPartial() {
byte[] val = DUMMY;
byte[] leftval = hashed(val, 1, 1);
byte[] partialval = hashed(val, 1);
Range left = new Range(tok(-1), tok(4));
Range partial = new Range(tok(2), tok(4));
Range right = new Range(tok(4), tok(-1));
Range linvalid = new Range(tok(1), tok(4));
Range rinvalid = new Range(tok(4), tok(6));
// (zero,two] (two,four] (four, zero]
mt.split(tok(4));
mt.split(tok(2));
assertNull(mt.hash(left));
assertNull(mt.hash(partial));
assertNull(mt.hash(right));
assertNull(mt.hash(linvalid));
assertNull(mt.hash(rinvalid));
// validate the range
mt.get(tok(2)).hash(val);
mt.get(tok(4)).hash(val);
mt.get(tok(-1)).hash(val);
assertHashEquals(leftval, mt.hash(left));
assertHashEquals(partialval, mt.hash(partial));
assertHashEquals(val, mt.hash(right));
assertNull(mt.hash(linvalid));
assertNull(mt.hash(rinvalid));
}
@Test
public void testSplitLimitSize() {
mt = new MerkleTree(partitioner, RECOMMENDED_DEPTH, 2);
assertTrue(mt.split(tok(4)));
assertEquals(2, mt.size());
// should fail to split above maxsize
assertFalse(mt.split(tok(2)));
assertEquals(2, mt.size());
assertEquals(new Range(tok(4), tok(-1)), mt.get(tok(-1)));
assertEquals(new Range(tok(-1), tok(4)), mt.get(tok(4)));
}
@Test
public void testSplitLimitDepth() {
mt = new MerkleTree(partitioner, (byte) 2, Integer.MAX_VALUE);
assertTrue(mt.split(tok(4)));
assertTrue(mt.split(tok(2)));
assertEquals(3, mt.size());
// should fail to split below hashdepth
assertFalse(mt.split(tok(1)));
assertEquals(3, mt.size());
assertEquals(new Range(tok(4), tok(-1)), mt.get(tok(-1)));
assertEquals(new Range(tok(-1), tok(2)), mt.get(tok(2)));
assertEquals(new Range(tok(2), tok(4)), mt.get(tok(4)));
}
@Test
public void testCompactHash() {
byte[] val = DUMMY;
byte[] valXval = hashed(val, 1, 1);
// (zero, four], (four,zero]
mt.split(tok(4));
// validate both ranges
mt.get(tok(4)).hash(val);
mt.get(tok(-1)).hash(val);
// compact (zero, eight]
mt.compact(tok(4));
assertHashEquals(valXval, mt.get(tok(-1)).hash());
}
@Test
public void testInvalids() {
Iterator<TreeRange> ranges;
// (zero, zero]
ranges = mt.invalids(new Range(tok(-1), tok(-1)));
assertEquals(new Range(tok(-1), tok(-1)), ranges.next());
assertFalse(ranges.hasNext());
// all invalid
mt.split(tok(4));
mt.split(tok(2));
mt.split(tok(6));
mt.split(tok(3));
mt.split(tok(5));
ranges = mt.invalids(new Range(tok(-1), tok(-1)));
assertEquals(new Range(tok(-1), tok(2)), ranges.next());
assertEquals(new Range(tok(2), tok(3)), ranges.next());
assertEquals(new Range(tok(3), tok(4)), ranges.next());
assertEquals(new Range(tok(4), tok(5)), ranges.next());
assertEquals(new Range(tok(5), tok(6)), ranges.next());
assertEquals(new Range(tok(6), tok(-1)), ranges.next());
assertFalse(ranges.hasNext());
// some invalid
mt.get(tok(2)).hash("non-null!".getBytes());
mt.get(tok(4)).hash("non-null!".getBytes());
mt.get(tok(5)).hash("non-null!".getBytes());
mt.get(tok(-1)).hash("non-null!".getBytes());
ranges = mt.invalids(new Range(tok(-1), tok(-1)));
assertEquals(new Range(tok(2), tok(3)), ranges.next());
assertEquals(new Range(tok(5), tok(6)), ranges.next());
assertFalse(ranges.hasNext());
// some invalid in left subrange
ranges = mt.invalids(new Range(tok(-1), tok(6)));
assertEquals(new Range(tok(2), tok(3)), ranges.next());
assertEquals(new Range(tok(5), tok(6)), ranges.next());
assertFalse(ranges.hasNext());
// some invalid in right subrange
ranges = mt.invalids(new Range(tok(2), tok(-1)));
assertEquals(new Range(tok(2), tok(3)), ranges.next());
assertEquals(new Range(tok(5), tok(6)), ranges.next());
assertFalse(ranges.hasNext());
}
@Test
public void testSplit() {
// split the range (zero, zero] into:
// (zero,four], (four,six], (six,seven] and (seven, zero]
mt.split(tok(4));
mt.split(tok(6));
mt.split(tok(7));
assertEquals(4, mt.size());
assertEquals(new Range(tok(7), tok(-1)), mt.get(tok(-1)));
assertEquals(new Range(tok(-1), tok(4)), mt.get(tok(3)));
assertEquals(new Range(tok(-1), tok(4)), mt.get(tok(4)));
assertEquals(new Range(tok(4), tok(6)), mt.get(tok(6)));
assertEquals(new Range(tok(6), tok(7)), mt.get(tok(7)));
// check depths
assertEquals((byte) 1, mt.get(tok(4)).depth);
assertEquals((byte) 2, mt.get(tok(6)).depth);
assertEquals((byte) 3, mt.get(tok(7)).depth);
assertEquals((byte) 3, mt.get(tok(-1)).depth);
try {
mt.split(tok(-1));
fail("Shouldn't be able to split outside the initial range.");
} catch (AssertionError e) {
// pass
}
}
@Test
public void testHashFull() {
byte[] val = DUMMY;
Range range = new Range(tok(-1), tok(-1));
// (zero, zero]
assertNull(mt.hash(range));
// validate the range
mt.get(tok(-1)).hash(val);
assertHashEquals(val, mt.hash(range));
}
@Test
public void testDifference() {
Range full = new Range(tok(-1), tok(-1));
int maxsize = 16;
mt.maxsize(maxsize);
MerkleTree mt2 = new MerkleTree(partitioner, RECOMMENDED_DEPTH, maxsize);
mt.init();
mt2.init();
TreeRange leftmost = null;
TreeRange middle = null;
TreeRange rightmost = null;
// compact the leftmost, and split the rightmost
Iterator<TreeRange> ranges = mt.invalids(full);
leftmost = ranges.next();
rightmost = null;
while (ranges.hasNext()) rightmost = ranges.next();
mt.compact(leftmost.right);
leftmost = mt.get(leftmost.right); // leftmost is now a larger range
mt.split(rightmost.right);
// set the hash for the left neighbor of rightmost
middle = mt.get(rightmost.left);
middle.hash("arbitrary!".getBytes());
byte depth = middle.depth;
// add dummy hashes to the rest of both trees
for (TreeRange range : mt.invalids(full)) range.addAll(new HIterator(range.right));
for (TreeRange range : mt2.invalids(full)) range.addAll(new HIterator(range.right));
// trees should disagree for leftmost, (middle.left, rightmost.right]
List<TreeRange> diffs = MerkleTree.difference(mt, mt2);
assertEquals(diffs + " contains wrong number of differences:", 2, diffs.size());
assertTrue(diffs.contains(leftmost));
assertTrue(diffs.contains(new Range(middle.left, rightmost.right)));
}
@Test
public void testCompact() {
// (zero, one], (one,two], ... (seven, zero]
mt.split(tok(4));
mt.split(tok(2));
mt.split(tok(6));
mt.split(tok(1));
mt.split(tok(3));
mt.split(tok(5));
mt.split(tok(7));
// compact (zero,two] and then (four,six]
mt.compact(tok(1));
mt.compact(tok(5));
assertEquals(6, mt.size());
assertEquals(new Range(tok(-1), tok(2)), mt.get(tok(2)));
assertEquals(new Range(tok(2), tok(3)), mt.get(tok(3)));
assertEquals(new Range(tok(3), tok(4)), mt.get(tok(4)));
assertEquals(new Range(tok(4), tok(6)), mt.get(tok(5)));
assertEquals(new Range(tok(6), tok(7)), mt.get(tok(7)));
assertEquals(new Range(tok(7), tok(-1)), mt.get(tok(-1)));
// compacted ranges should be at depth 2, and the rest at 3
for (int i : new int[] {2, 6}) {
assertEquals((byte) 2, mt.get(tok(i)).depth);
}
for (int i : new int[] {3, 4, 7, -1}) {
assertEquals((byte) 3, mt.get(tok(i)).depth);
}
// compact (two,four] and then (six,zero]
mt.compact(tok(3));
mt.compact(tok(7));
assertEquals(4, mt.size());
assertEquals(new Range(tok(-1), tok(2)), mt.get(tok(2)));
assertEquals(new Range(tok(2), tok(4)), mt.get(tok(4)));
assertEquals(new Range(tok(4), tok(6)), mt.get(tok(5)));
assertEquals(new Range(tok(6), tok(-1)), mt.get(tok(-1)));
for (int i : new int[] {2, 4, 5, -1}) {
assertEquals((byte) 2, mt.get(tok(i)).depth);
}
// compact (zero,four]
mt.compact(tok(2));
assertEquals(3, mt.size());
assertEquals(new Range(tok(-1), tok(4)), mt.get(tok(2)));
assertEquals(new Range(tok(4), tok(6)), mt.get(tok(6)));
assertEquals(new Range(tok(6), tok(-1)), mt.get(tok(-1)));
// compact (four, zero]
mt.compact(tok(6));
assertEquals(2, mt.size());
assertEquals(new Range(tok(-1), tok(4)), mt.get(tok(2)));
assertEquals(new Range(tok(4), tok(-1)), mt.get(tok(6)));
assertEquals((byte) 1, mt.get(tok(2)).depth);
assertEquals((byte) 1, mt.get(tok(6)).depth);
// compact (zero, zero] (the root)
mt.compact(tok(4));
assertEquals(1, mt.size());
assertEquals(new Range(tok(-1), tok(-1)), mt.get(tok(-1)));
assertEquals((byte) 0, mt.get(tok(-1)).depth);
}