How to use com.palantir.atlasdb.jepsen

@Override
public void visit(InfoEvent event) {
  if (isNemesisEvent(event)) {
    if (isStartEvent(event)) {
      startAwaitingInvokeOkCycles(event);
    } else if (isStopEvent(event) && awaitingInvokeOkCycle) {
      addUnsurvivedEvents(event);
    }
  }
}

public static JepsenHistoryChecker createWithLockCheckers() {
  return createWithCheckers(LOCK_CHECKERS);
}

@Override
public CheckerResult check(List<Event> events) {
  Visitor visitor = new NemesisResilienceChecker.Visitor();
  events.forEach(event -> event.accept(visitor));
  return ImmutableCheckerResult.builder()
      .valid(visitor.valid())
      .errors(visitor.errors())
      .build();
}

@Override
public CheckerResult check(List<Event> events) {
  Visitor visitor = new Visitor();
  events.forEach(event -> event.accept(visitor));
  return ImmutableCheckerResult.builder()
      .valid(visitor.valid())
      .errors(visitor.errors())
      .build();
}

@Override
public CheckerResult check(List<Event> events) {
  Visitor visitor = new Visitor();
  events.forEach(event -> event.accept(visitor));
  return ImmutableCheckerResult.builder()
      .valid(visitor.valid())
      .errors(visitor.errors())
      .build();
}

@Override
public CheckerResult check(List<Event> events) {
  Visitor visitor = new Visitor();
  events.forEach(event -> event.accept(visitor));
  visitor.verifyLockCorrectness();
  return ImmutableCheckerResult.builder()
      .valid(visitor.valid())
      .errors(visitor.errors())
      .build();
}

public static CheckerResult combine(List<CheckerResult> results) {
  return ImmutableCheckerResult.builder()
      .valid(results.stream()
          .allMatch(CheckerResult::valid))
      .errors(results.stream()
          .flatMap(result -> result.errors().stream())
          .collect(Collectors.toList()))
      .build();
}

private static Map<Keyword, Object> createClojureMapFromResults(CheckerResult results) {
  List<Map<Keyword, Object>> errorsAsClojureHistory = convertEventListToClojureHistory(results.errors());
  return ImmutableMap.of(
      Keyword.intern("valid?"), results.valid(),
      Keyword.intern("errors"), errorsAsClojureHistory);
}

private static CheckerResult runIsolatedProcessRefreshSuccessChecker(List<Event> events) {
  Checker isolatedProcessCorrectnessChecker =
      new PartitionByInvokeNameCheckerHelper(IsolatedProcessCorrectnessChecker::new);
  return isolatedProcessCorrectnessChecker.check(events);
}

  private static void assertNoError(List<Event> events) {
    CheckerTestUtils.assertNoErrors(() ->
        new PartitionByInvokeNameCheckerHelper(IsolatedProcessCorrectnessChecker::new), events);
  }
}

@Test
public void canCreateWithTimestampCheckers() {
  JepsenHistoryChecker checker = JepsenHistoryCheckers.createWithTimestampCheckers();
  assertCheckerHasMatchingCheckers(JepsenHistoryCheckers.TIMESTAMP_CHECKERS, checker);
  assertThat(checker.getCheckers()).hasSize(JepsenHistoryCheckers.TIMESTAMP_CHECKERS.size());
}

@Test
public void canCreateWithLockCheckers() {
  JepsenHistoryChecker checker = JepsenHistoryCheckers.createWithLockCheckers();
  assertCheckerHasMatchingCheckers(JepsenHistoryCheckers.LOCK_CHECKERS, checker);
  assertThat(checker.getCheckers()).hasSize(JepsenHistoryCheckers.LOCK_CHECKERS.size());
}

/**
 * Parses a history of events from a Jepsen test of the timestamp service, and verifies that it fits the model.
 * In particular, the timestamp values should be monotonically increasing for each process. See MonotonicChecker for
 * more details.
 *
 * @param clojureHistory A history of events. This is a list of maps, for example:
 *     [{":type": "invoke", "process": 0, "time", 0L},
 *      {":type": "ok",     "process": 0, "time": 0L, "value", 10L}]
 * @return A map of
 *     :valid?     A boolean of whether the check passes
 *     :errors     A list of events that failed the check, or an empty list if the check passed
 * @throws RuntimeException if the parsing of the history fails.
 */
public Map<Keyword, Object> checkClojureHistory(List<Map<Keyword, ?>> clojureHistory) {
  List<Event> events = convertClojureHistoryToEventList(clojureHistory);
  return checkHistory(events);
}

private static CheckerResult runPartitionChecker(Supplier<Checker> checker, List<Event> events) {
  PartitionByInvokeNameCheckerHelper partitionByInvokeNameCheckerHelper =
      new PartitionByInvokeNameCheckerHelper(checker);
  return partitionByInvokeNameCheckerHelper.check(events);
}

  private static CheckerResult runNemesisResilienceChecker(Event... events) {
    NemesisResilienceChecker nemesisResilienceChecker = new NemesisResilienceChecker();
    return nemesisResilienceChecker.check(ImmutableList.copyOf(events));
  }
}

@Test
public void createsDistinctCheckerInstances() {
  JepsenHistoryChecker checker1 = JepsenHistoryCheckers.createWithTimestampCheckers();
  JepsenHistoryChecker checker2 = JepsenHistoryCheckers.createWithTimestampCheckers();
  for (Checker checkerFromCheckerOne : checker1.getCheckers()) {
    for (Checker checkerFromCheckerTwo : checker2.getCheckers()) {
      assertThat(checkerFromCheckerOne).isNotSameAs(checkerFromCheckerTwo);
    }
  }
}

  private CheckerResult combineResults(List<CheckerResult> results) {
    List<Event> allErrors = results.stream().flatMap(result ->
        result.errors().stream()).collect(Collectors.toList());
    boolean allValid = results.stream().allMatch(CheckerResult::valid);
    return ImmutableCheckerResult.builder()
        .valid(allValid)
        .errors(allErrors)
        .build();
  }
}

  private static void assertNoError(List<Event> events) {
    CheckerTestUtils.assertNoErrors(() ->
        new PartitionByInvokeNameCheckerHelper(RefreshCorrectnessChecker::new), events);
  }
}

public static JepsenHistoryChecker createWithTimestampCheckers() {
  return createWithCheckers(TIMESTAMP_CHECKERS);
}

  private static void assertNoError(List<Event> events) {
    CheckerTestUtils.assertNoErrors(() -> new PartitionByInvokeNameCheckerHelper(LockCorrectnessChecker::new),
        events);
  }
}