@Test
  public void testSerialization() throws Exception {
    Range<Token> first = new Range<>(tok(3), tok(4));

    Collection<Range<Token>> ranges = new ArrayList<>();

    ranges.add(first);
    ranges.add(new Range<Token>(tok(5), tok(2)));

    mts = new MerkleTrees(partitioner);
    mts.addMerkleTrees(256, ranges);

    // populate and validate the tree
    mts.init();
    for (TreeRange range : mts.invalids()) range.addAll(new HIterator(range.right));

    byte[] initialhash = mts.hash(first);

    long serializedSize =
        MerkleTrees.serializer.serializedSize(mts, MessagingService.current_version);
    DataOutputBuffer out = new DataOutputBuffer();
    MerkleTrees.serializer.serialize(mts, out, MessagingService.current_version);
    byte[] serialized = out.toByteArray();

    assertEquals(serializedSize, serialized.length);

    DataInputBuffer in = new DataInputBuffer(serialized);
    MerkleTrees restored = MerkleTrees.serializer.deserialize(in, MessagingService.current_version);

    assertHashEquals(initialhash, restored.hash(first));
  }
Ejemplo n.º 2
0
  @Test
  public void testHashRandom() {
    int max = 1000000;
    TOKEN_SCALE = new BigInteger("" + max);

    mt = new MerkleTree(partitioner, RECOMMENDED_DEPTH, 32);
    Random random = new Random();
    while (true) {
      if (!mt.split(tok(random.nextInt(max)))) break;
    }

    // validate the tree
    TreeRangeIterator ranges = mt.invalids(new Range(tok(-1), tok(-1)));
    for (TreeRange range : ranges) range.addHash(new RowHash(range.right, new byte[0]));

    assert null != mt.hash(new Range(tok(-1), tok(-1))) : "Could not hash tree " + mt;
  }
  @Test
  public void testHashRandom() {
    int max = 1000000;
    TOKEN_SCALE = new BigInteger("" + max);

    mts = new MerkleTrees(partitioner);
    mts.addMerkleTree(32, fullRange());

    Random random = new Random();
    while (true) {
      if (!mts.split(tok(random.nextInt(max)))) break;
    }

    // validate the tree
    TreeRangeIterator ranges = mts.invalids();
    for (TreeRange range : ranges) range.addHash(new RowHash(range.right, new byte[0], 0));

    assert mts.hash(new Range<>(tok(-1), tok(-1))) != null : "Could not hash tree " + mts;
  }
Ejemplo n.º 4
0
  @Test
  public void testSerialization() throws Exception {
    Range full = new Range(tok(-1), tok(-1));
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    ObjectOutputStream oout = new ObjectOutputStream(bout);

    // populate and validate the tree
    mt.maxsize(256);
    mt.init();
    for (TreeRange range : mt.invalids(full)) range.addAll(new HIterator(range.right));

    byte[] initialhash = mt.hash(full);
    oout.writeObject(mt);
    oout.close();

    ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
    ObjectInputStream oin = new ObjectInputStream(bin);
    MerkleTree restored = (MerkleTree) oin.readObject();

    // restore partitioner after serialization
    restored.partitioner(partitioner);

    assertHashEquals(initialhash, restored.hash(full));
  }
  @Test
  public void testDifference() {
    int maxsize = 16;
    mts = new MerkleTrees(partitioner);
    mts.addMerkleTree(32, fullRange());

    MerkleTrees mts2 = new MerkleTrees(partitioner);
    mts2.addMerkleTree(32, fullRange());

    mts.init();
    mts2.init();

    // add dummy hashes to both trees
    for (TreeRange range : mts.invalids()) range.addAll(new HIterator(range.right));
    for (TreeRange range : mts2.invalids()) range.addAll(new HIterator(range.right));

    TreeRange leftmost = null;
    TreeRange middle = null;

    mts.maxsize(fullRange(), maxsize + 2); // give some room for splitting

    // split the leftmost
    Iterator<TreeRange> ranges = mts.invalids();
    leftmost = ranges.next();
    mts.split(leftmost.right);

    // set the hashes for the leaf of the created split
    middle = mts.get(leftmost.right);
    middle.hash("arbitrary!".getBytes());
    mts.get(partitioner.midpoint(leftmost.left, leftmost.right))
        .hash("even more arbitrary!".getBytes());

    // trees should disagree for (leftmost.left, middle.right]
    List<Range<Token>> diffs = MerkleTrees.difference(mts, mts2);
    assertEquals(diffs + " contains wrong number of differences:", 1, diffs.size());
    assertTrue(diffs.contains(new Range<>(leftmost.left, middle.right)));
  }
Ejemplo n.º 6
0
  @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)));
  }