How to use

valid

method

in

com.palantir.atlasdb.jepsen.ImmutableCheckerResult$Builder

  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();
  }
}

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 Checker createMockedChecker(boolean valid, Map<Keyword, ?> ... errors) {
    List<Map<Keyword, ?>> listOfErrors = ImmutableList.copyOf(errors);
    List<Event> listOfErrorsAsEvents = listOfErrors.stream()
        .map(Event::fromKeywordMap)
        .collect(Collectors.toList());

    Checker checker = mock(Checker.class);
    CheckerResult result = ImmutableCheckerResult.builder()
        .valid(valid)
        .errors(listOfErrorsAsEvents)
        .build();
    when(checker.check(any())).thenReturn(result);
    return checker;
  }
}

private CheckerResult checkLockName(String lockName, List<Event> events) {
  boolean noOtherLock = true;
  boolean atLeastOneInvoke = false;
  for (Event event : events) {
    if (event instanceof InvokeEvent) {
      atLeastOneInvoke = true;
      InvokeEvent invokeEvent = (InvokeEvent) event;
      if (!invokeEvent.value().equals(lockName)) {
        noOtherLock = false;
      }
    }
  }
  if (noOtherLock && atLeastOneInvoke) {
    return ImmutableCheckerResult.builder()
        .valid(false)
        .errors(events)
        .build();
  } else {
    return ImmutableCheckerResult.builder()
        .valid(true)
        .errors(new ArrayList<>())
        .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();
}

@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));
  return ImmutableCheckerResult.builder()
      .valid(visitor.valid())
      .errors(visitor.errors())
      .build();
}