// required. These socket factories explicitly set the buffer sizes on sockets created.
    server = MockWebServer()
    server.serverSocketFactory =
      object : DelegatingServerSocketFactory(getDefault()) {
        @Throws(SocketException::class)
        override fun configureServerSocket(serverSocket: ServerSocket): ServerSocket {

        return new RegularImmutableSortedSet<>(asImmutableList(elements, n), comparator);
      }
    }
  }

  int unsafeCompare(Object a, @Nullable Object b) {
    return unsafeCompare(comparator, a, b);
  }

  static int unsafeCompare(Comparator<?> comparator, Object a, @Nullable Object b) {
    // Pretend the comparator can compare anything. If it turns out it can't

     * undirected.
     *
     * <p>If {@code nodeU} and {@code nodeV} are not already present in this graph, this method will
     * silently {@link #addNode(Object) add} {@code nodeU} and {@code nodeV} to the graph.
     *
     * @return this {@code Builder} object
     * @throws IllegalArgumentException if the introduction of the edge would violate {@link
     *     #allowsSelfLoops()}
     */
    @CanIgnoreReturnValue

    /**
     * Test getKeys method when subject has Kerberos keys.
     *
     * @throws LoginException if login fails.
     */
    @Test
    void testGetKeys_WithKeys() throws LoginException {
        Set<Object> privateCredentials = new HashSet<>();
        privateCredentials.add(key1);
        privateCredentials.add(key2);
        when(subject.getPrivateCredentials()).thenReturn(privateCredentials);

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.hash.Hashing.murmur3_32_fixed;
import static java.lang.Math.max;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.base.CharMatcher;
import com.google.common.base.MoreObjects;

)

open class ErrorProneSourceSetExtension(
    val enabled: Property<Boolean>
)

val errorproneExtension = project.extensions.create<ErrorProneProjectExtension>(
    "errorprone",
    objects.listProperty<String>(),
    objects.property<Boolean>()
).apply {
    disabledChecks.addAll(
        // ENABLE
        "PatternMatchingInstanceof", // We should enable this.

import org.eclipse.aether.transfer.TransferResource;

/**
 * Immutable identifier of a {@link TransferResource}.
 * The {@link TransferResource} is not immutable and does not implement {@code Objects#equals} and {@code Objects#hashCode} methods,
 * making it not very suitable for usage in collections.
 */
@Deprecated
record TransferResourceIdentifier(
        String repositoryId,
        String repositoryUrl,

                    if (groupId != null && artifactId != null) {
                        boolean isProjectArtifact = allGAVs.stream()
                                .anyMatch(gav -> Objects.equals(gav.groupId(), groupId)
                                        && Objects.equals(gav.artifactId(), artifactId));

                        if (isProjectArtifact) {

    assertEquals(0L, map.get(key));
    assertFalse(map.containsKey(key));
  }

  public void testRemoveZeros() {
    AtomicLongMap<Object> map = AtomicLongMap.create();
    Set<Object> nonZeroKeys = new HashSet<>();
    for (int i = 0; i < ITERATIONS; i++) {
      Object key = new Object();
      long value = i % 2;
      map.put(key, value);
      if (value != 0L) {
        nonZeroKeys.add(key);
      }
    }

    return Optional.absent();
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return this == obj;
  }

  @Override
  public int hashCode() {
    return 0x79a31aac;
  }

  @Override
  public String toString() {
    return "Optional.absent()";
  }

  private Object readResolve() {
    return INSTANCE;
  }