import java.net.InetAddress
import java.net.UnknownHostException
import java.util.Collections
import okio.Buffer

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> =
    Collections.synchronizedMap(mutableMapOf())
  private val requestedHosts: MutableList<String> = Collections.synchronizedList(mutableListOf())

        DefaultMavenMetadataCache.CacheKey k1 =
                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =
                new DefaultMavenMetadataCache.CacheKey(a2, false, lr2, Collections.singletonList(rr2));

        assertEquals(k1.hashCode(), k2.hashCode());
    }

    }

    @Test
    void testV4ModelPriority() {
        Model m = model.withBuild(Build.newInstance()
                .withPlugins(Collections.singleton(Plugin.newInstance()
                        .withExecutions(Collections.singleton(
                                PluginExecution.newInstance().withPriority(5))))));
        assertEquals("4.0.0", new MavenModelVersion().getModelVersion(m));
    }

    public CoreExports(ClassRealm realm, Set<String> exportedArtifacts, Set<String> exportedPackages) {
        this.artifacts = Collections.unmodifiableSet(new HashSet<>(exportedArtifacts));
        this.packages = exportedPackages.stream()
                .collect(collectingAndThen(toMap(identity(), v -> realm), Collections::unmodifiableMap));
    }

    /**

 */
package okhttp3.internal.connection

import java.io.IOException
import okhttp3.Address
import okhttp3.HttpUrl

/**
 * Policy on choosing which connection to use for an exchange and any retries that follow. This uses
 * the following strategies:
 *
 *  1. If the current call already has a connection that can satisfy the request it is used. Using

import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.MalformedURLException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

            @Override
            public java.util.List<LaScheduledJob> getJobList() {
                return Collections.emptyList();
            }

            @Override
            public java.util.List<org.lastaflute.job.LaJobHistory> searchJobHistoryList() {
                return Collections.emptyList();
            }

            @Override
            public void reboot() {
            }

 *  * attempt to find a connection
 *  * step through time, asserting that the expected side effects are performed.
 */
internal class FastFallbackExchangeFinderTest {
  private val taskFaker = TaskFaker()
  private val taskRunner = taskFaker.taskRunner

  /**
   * Note that we don't use the same [TaskFaker] for this factory. That way off-topic tasks like

   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.
   * - The coalesced connection is violently closed after servicing the first request.

    assertLockNotHeld()

    val connection = this.connection
    if (connection != null) {
      connection.assertLockNotHeld()
      val toClose: Socket? =
        connection.withLock {
          // Sets this.connection to null.
          releaseConnectionNoEvents()
        }
      if (this.connection == null) {
        toClose?.closeQuietly()