private static CheckerResult runUniquenessChecker(Event... events) { UniquenessChecker uniquenessChecker = new UniquenessChecker(); return uniquenessChecker.check(ImmutableList.copyOf(events)); } }
private static CheckerResult runChecker(Event... events) { NonOverlappingReadsMonotonicChecker checker = new NonOverlappingReadsMonotonicChecker(); return checker.check(ImmutableList.copyOf(events)); } }
private static CheckerResult runMonotonicChecker(Event... events) { MonotonicChecker monotonicChecker = new MonotonicChecker(); return monotonicChecker.check(ImmutableList.copyOf(events)); } }
@Test public void shouldThrowIfOkEventHasNonIntegerValue() { Event event1 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, NOOP); Event event2 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, NOOP); assertThatThrownBy(() -> runMonotonicChecker(event1, event2)) .isInstanceOf(NumberFormatException.class); }
@Test public void shouldSucceedOnNoEvents() { CheckerResult result = runChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Test public void shouldSuceeedOnNoEvents() { CheckerResult result = runUniquenessChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Override public void visit(OkEvent event) { int process = event.process(); InvokeEvent invoke = pendingReadForProcess.get(process); if (invoke != null) { validateTimestampHigherThanReadsCompletedBeforeInvoke(invoke, event); } pendingReadForProcess.remove(process); acknowledgedReadsOverTime.add(event); }
private void validateTimestampHigherThanReadsCompletedBeforeInvoke(InvokeEvent invoke, OkEvent event) { OkEvent lastAcknowledgedRead = lastAcknowledgedReadBefore(invoke.time()); if (lastAcknowledgedRead != null) { long timestamp = Long.parseLong(event.value()); long lastAcknowledgedTimestamp = Long.parseLong(lastAcknowledgedRead.value()); if (lastAcknowledgedTimestamp >= timestamp) { errors.add(lastAcknowledgedRead); errors.add(invoke); errors.add(event); } } }
@Test public void shouldThrowIfOkEventHasNonIntegerValue() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "1"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_0, "noop"); NonOverlappingReadsMonotonicChecker checker = new NonOverlappingReadsMonotonicChecker(); assertThatThrownBy(() -> checker.check(ImmutableList.of(event1, event2, event3, event4))) .isInstanceOf(NumberFormatException.class); }
@Test public void shouldSucceedOnNoEvents() { CheckerResult result = runMonotonicChecker(); assertThat(result.valid()).isTrue(); assertThat(result.errors()).isEmpty(); }
@Test public void shouldFailOnDecreasingConfirmedReadsOnOneProcess() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "1"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); CheckerResult result = runChecker(event1, event2, event3, event4); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event2, event3, event4); }
@Test public void shouldFailIfSameValueAppearsOnTwoProcesses() { Event event1 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, VALUE_A); Event event2 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_1, VALUE_A); CheckerResult result = runUniquenessChecker(event1, event2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event2); }
@Test public void shouldFailOnDecreasingValueEvents() { Event event1 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, "1"); Event event2 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, "0"); CheckerResult result = runMonotonicChecker(event1, event2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event2); }
@Test public void shouldFailOnEqualConfirmedReads() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_0, "0"); CheckerResult result = runChecker(event1, event2, event3, event4); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event2, event3, event4); }
@Test public void shouldFailIfSameValueAppearsAfterDifferentValue() { long time = 0; Event event1 = TestEventUtils.timestampOk(time++, PROCESS_0, VALUE_A); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_1, VALUE_B); Event event3 = TestEventUtils.timestampOk(time++, PROCESS_1, VALUE_A); CheckerResult result = runUniquenessChecker(event1, event2, event3); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event3); }
@Test public void shouldFailOnEqualEntries() { Event event1 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, "0"); Event event2 = TestEventUtils.timestampOk(ZERO_TIME, PROCESS_0, "0"); CheckerResult result = runMonotonicChecker(event1, event2); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event1, event2); }
@Test public void shouldFailOnDecreasingConfirmedReadsAcrossTwoProcesses() { long time = 0; Event event1 = TestEventUtils.invokeTimestamp(time++, PROCESS_0); Event event2 = TestEventUtils.timestampOk(time++, PROCESS_0, "1"); Event event3 = TestEventUtils.invokeTimestamp(time++, PROCESS_1); Event event4 = TestEventUtils.timestampOk(time++, PROCESS_1, "0"); CheckerResult result = runChecker(event1, event2, event3, event4); assertThat(result.valid()).isFalse(); assertThat(result.errors()).containsExactly(event2, event3, event4); }