"member": "Method org.gradle.api.plugins.quality.Checkstyle.getInstantiator()",
                        "changes": ["Method has been removed"],
                        "acceptation": "use ObjectFactory instead"
                    },
                    {
                        "type": "org.gradle.api.plugins.quality.CodeNarc",

        assertThat(lru.get("aaa"), is("111"));
        Iterator<String> i = lru.keySet().iterator();
        assertThat(i.next(), is("bbb"));
        assertThat(i.next(), is("ccc"));
        assertThat(i.next(), is("aaa"));
        lru.put("ddd", "444");
        assertThat(lru.size(), is(3));
        assertThat(lru.get("bbb"), is(nullValue()));
        i = lru.keySet().iterator();
        assertThat(i.next(), is("ccc"));

  }

  /**
   * Returns a composite adapter for a struct or data class. This may be used for both SEQUENCE and
   * SET types.
   *
   * The fields are specified as a list of member adapters. When decoding, a value for each
   * non-optional member but be included in sequence.
   *
   * TODO: for sets, sort by tag when encoding.
   * TODO: for set ofs, sort by encoded value when encoding.
   */
  fun <T> sequence(

            return accessor.getBinaryCompatibility() == BinaryCompatibility.ACCESSORS_KEPT;
        });
        if (!keptAccessors.isEmpty()) {
            String formattedLeft = CollectionUtils.join("\n", keptAccessors.keySet());
            throw new RuntimeException("The following accessors were upgraded, but didn't match any removed/changed method:\n\n" + formattedLeft);
        }

        // Find accessors that were removed but shouldn't be

import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import java.util.Spliterator;
import java.util.function.Consumer;
import org.jspecify.annotations.Nullable;

/**
 * {@code keySet()} implementation for {@link ImmutableMap}.
 *
 * @author Jesse Wilson
 * @author Kevin Bourrillion
 */
@GwtCompatible
final class ImmutableMapKeySet<K, V> extends IndexedImmutableSet<K> {

                    // with the sort used by AbstractAcceptedApiChangesMaintenanceTask.
                    result.acceptedApiChanges.sort((a, b) => {
                        if ((a.type +'#' + a.member) > (b.type + '#' + b.member)) {
                            return 1;
                        } else {
                            return -1;
                        }
                    });

    }
  }

  private transient @Nullable ImmutableSortedSet<K> keySet;

  @Override
  public ImmutableSortedSet<K> keySet() {
    ImmutableSortedSet<K> ks = keySet;
    return (ks == null) ? (keySet = createKeySet()) : ks;
  }

  @Override
  ImmutableSortedSet<K> createKeySet() {
    // the keySet() of the delegate is only a Set and TreeMap.navigatableKeySet

        interfaces = ['internal': internalInterface,
                      'incubating': incubatingInterface]
    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

    def "nothing should be reported if no changes"() {

    assertThat(referenceQuantiles.keySet()).isEqualTo(indexes);
    for (QuantilesAlgorithm algorithm : NON_REFERENCE_ALGORITHMS) {
      Map<Integer, Double> quantiles = algorithm.multipleQuantiles(indexes, 100, dataset.clone());
      assertWithMessage("Wrong keys from %s", algorithm)
          .that(quantiles.keySet())
          .isEqualTo(indexes);
      for (int i : indexes) {

    return Collections.unmodifiableSet(adjacentNodeValues.keySet());
  }

  @Override
  public Set<N> predecessors() {
    return adjacentNodes();
  }

  @Override
  public Set<N> successors() {
    return adjacentNodes();
  }

  @Override
  public Iterator<EndpointPair<N>> incidentEdgeIterator(N thisNode) {
    return Iterators.transform(
        adjacentNodeValues.keySet().iterator(),