public void testEmptyStateIsEmpty() {
    assertNull(target.getSnapshot());
    assertEquals(V0, target.getCurrentVersion());
    assertEquals(V0, target.getHashedVersion(0));

    assertNull(target.getTransformedDelta(V0));
    assertNull(target.getAppliedDelta(V0));
  }
 public void checkManyDeltasPersistFutureDone() throws Exception {
   appendDeltas(d1, d2, d3);
   Future<Void> future = target.persist(d3.getResultingVersion());
   awaitPersistence();
   assertTrue(future.isDone());
   assertEquals(null, future.get());
   assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion());
 }
 public void testHashedVersionAccessibleOnDeltaBoundaries() throws Exception {
   appendDeltas(d1, d2, d3);
   assertEquals(V0, target.getHashedVersion(0));
   assertEquals(d1.getResultingVersion(), target.getHashedVersion(2));
   assertEquals(d2.getResultingVersion(), target.getHashedVersion(4));
   assertEquals(d3.getResultingVersion(), target.getHashedVersion(5));
   assertNull(target.getHashedVersion(1));
   assertNull(target.getHashedVersion(3));
   assertNull(target.getHashedVersion(6));
 }
  public void testCanPersistOnlySomeDeltas() throws Exception {
    appendDeltas(d1, d2, d3);
    Future<Void> future = target.persist(d2.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d2.getResultingVersion(), target.getLastPersistedVersion());

    future = target.persist(d3.getResultingVersion());
    awaitPersistence();
    assertTrue(future.isDone());
    assertEquals(null, future.get());
    assertEquals(d3.getResultingVersion(), target.getLastPersistedVersion());
  }
  public void testSingleDeltaHistoryAccessible() throws Exception {
    appendDeltas(d1);
    DeltaSequence transformedHistory =
        target.getTransformedDeltaHistory(V0, d1.getResultingVersion());
    assertNotNull(transformedHistory);
    assertEquals(1, transformedHistory.size());
    assertEquals(d1.transformed, transformedHistory.get(0));

    Collection<ByteStringMessage<ProtocolAppliedWaveletDelta>> appliedHistory =
        target.getAppliedDeltaHistory(V0, d1.getResultingVersion());
    assertNotNull(appliedHistory);
    assertEquals(1, appliedHistory.size());
    assertEquals(d1.applied, Iterables.getOnlyElement(appliedHistory));
  }
  public void testDeltasAccesssibleByEndVersion() throws Exception {
    appendDeltas(d1, d2, d3);
    for (WaveletDeltaRecord d : Arrays.asList(d1, d2, d3)) {
      assertEquals(d.transformed, target.getTransformedDeltaByEndVersion(d.getResultingVersion()));
      assertEquals(d.applied, target.getAppliedDeltaByEndVersion(d.getResultingVersion()));
    }

    // Wrong hashes return null.
    assertNull(
        target.getTransformedDeltaByEndVersion(
            HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
    assertNull(
        target.getAppliedDeltaByEndVersion(
            HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
  }
  public void testDeltaHistoryRequiresCorrectHash() throws Exception {
    appendDeltas(d1);

    // Wrong start hash.
    assertNull(
        target.getTransformedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion()));
    assertNull(target.getAppliedDeltaHistory(HashedVersion.unsigned(0), d1.getResultingVersion()));

    // Wrong end hash.
    assertNull(
        target.getTransformedDeltaHistory(
            V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
    assertNull(
        target.getAppliedDeltaHistory(
            V0, HashedVersion.unsigned(d1.getResultingVersion().getVersion())));
  }
  public void testSnapshotMetadataReflectsDeltas() throws Exception {
    HashedVersion v2 = d1.getResultingVersion();
    appendDeltas(d1);

    assertEquals(v2, target.getCurrentVersion());
    ReadableWaveletData snapshot = target.getSnapshot();
    assertEquals(AUTHOR, snapshot.getCreator());
    assertEquals(v2, snapshot.getHashedVersion());
    assertEquals(TS, snapshot.getCreationTime());
    assertEquals(TS, snapshot.getLastModifiedTime());
    assertEquals(2, snapshot.getVersion());

    HashedVersion v4 = d2.getResultingVersion();
    appendDeltas(d2);

    assertEquals(v4, target.getCurrentVersion());
    snapshot = target.getSnapshot();
    assertEquals(v4, snapshot.getHashedVersion());
    assertEquals(4, snapshot.getVersion());
    // Last-modified-time doesn't change due to unworthiness.
  }
  /**
   * Checks that a request for the deltas spanning a contiguous sequence of delta facets produces
   * correct results.
   */
  private void checkHistoryForDeltas(WaveletDeltaRecord... deltas) {
    HashedVersion beginVersion = deltas[0].appliedAtVersion;
    HashedVersion endVersion = deltas[deltas.length - 1].transformed.getResultingVersion();

    {
      List<TransformedWaveletDelta> expected = Lists.newArrayListWithExpectedSize(deltas.length);
      for (WaveletDeltaRecord d : deltas) {
        expected.add(d.transformed);
      }
      assertEquals(expected, target.getTransformedDeltaHistory(beginVersion, endVersion));
    }
    {
      List<ByteStringMessage<ProtocolAppliedWaveletDelta>> expected =
          Lists.newArrayListWithExpectedSize(deltas.length);
      for (WaveletDeltaRecord d : deltas) {
        expected.add(d.applied);
      }
      assertTrue(
          Iterables.elementsEqual(
              expected, target.getAppliedDeltaHistory(beginVersion, endVersion)));
    }
  }
  public void testDeltasAccessibleByBeginVersion() throws Exception {
    appendDeltas(d1, d2, d3);
    assertEquals(d1.transformed, target.getTransformedDelta(V0));
    assertEquals(d1.applied, target.getAppliedDelta(V0));

    assertEquals(d2.transformed, target.getTransformedDelta(d1.getResultingVersion()));
    assertEquals(d2.applied, target.getAppliedDelta(d1.getResultingVersion()));

    assertEquals(d3.transformed, target.getTransformedDelta(d2.getResultingVersion()));
    assertEquals(d3.applied, target.getAppliedDelta(d2.getResultingVersion()));

    // Wrong hashes return null.
    assertNull(target.getTransformedDelta(HashedVersion.unsigned(0)));
    assertNull(target.getAppliedDelta(HashedVersion.unsigned(0)));
  }
 public void testReportsWaveletName() {
   assertEquals(NAME, target.getWaveletName());
 }
 /** Applies a delta to the target. */
 private void appendDeltas(WaveletDeltaRecord... deltas)
     throws InvalidProtocolBufferException, OperationException {
   for (WaveletDeltaRecord delta : deltas) {
     target.appendDelta(delta.appliedAtVersion, delta.transformed, delta.applied);
   }
 }