private static final String REVISION_PROPERTY = "revision";

    @Override
    public boolean isValidProperty(String property) {
        return REVISION_PROPERTY.equals(property)
                || CHANGELIST_PROPERTY.equals(property)
                || SHA1_PROPERTY.equals(property);
    }

    @Override
    public void overwriteModelProperties(Properties modelProperties, ModelBuildingRequest request) {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListLastIndexOfTester<E> extends AbstractListIndexOfTester<E> {
  @Override
  protected int find(Object o) {
    return getList().lastIndexOf(o);
  }

  @Override
  protected String getMethodName() {
    return "lastIndexOf";
  }

  @CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)

        inNodes.add(node);
        return this;
    }

    public MetadataGraphNode addExident(MetadataGraphNode node) {
        exNodes.add(node);
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (MetadataGraphNode.class.isAssignableFrom(obj.getClass())) {

@NullUnmarked
public class ByteSourceAsCharSourceReadBenchmark {
  enum ReadStrategy {
    TO_BYTE_ARRAY_NEW_STRING {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        return new String(byteSource.read(), cs);
      }
    },
    USING_CHARSTREAMS_COPY {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        StringBuilder sb = new StringBuilder();

    }

    for (int i = 0; i < otherEntriesInDataStructure; i++) {
      ClassValue<Boolean> classValue =
          new ClassValue<Boolean>() {
            @Override
            protected Boolean computeValue(Class<?> type) {
              return true;
            }
          };
      classValue.get(exceptionType);
      retainedReferencesToOtherClassValues.add(classValue);

    FakeTicker ticker = new FakeTicker();

    int numberOfThreads = 64;
    runConcurrentTest(
        numberOfThreads,
        new Callable<@Nullable Void>() {
          @Override
          public @Nullable Void call() throws Exception {
            // adds two nanoseconds to the ticker
            ticker.advance(1L);
            Thread.sleep(10);
            ticker.advance(1L);

     */
    public boolean isDeleted() {
        return isUpdated() && newToken.length() == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(pos, reading, segmentation, token);
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }

     */
    public boolean isDeleted() {
        return isUpdated() && newInputs.length == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(Arrays.hashCode(inputs), Arrays.hashCode(outputs));
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }

    testers.add(BiMapClearTester.class);
    return testers;
  }

  enum NoRecurse implements Feature<Void> {
    INVERSE;

    @Override
    public Set<Feature<? super Void>> getImpliedFeatures() {
      return emptySet();
    }
  }

  @Override
  protected List<TestSuite> createDerivedSuites(
      FeatureSpecificTestSuiteBuilder<

    this.caseDesc = checkNotNull(caseDesc);
  }

  @Override
  public String getName() {
    return super.getName() + " [" + suiteName + " [" + caseDesc + "]]";
  }

  protected static ImmutableList<String> getLines(String string) {
    try {
      return new CharSource() {
        @Override
        public Reader openStream() throws IOException {
          return new StringReader(string);