void testMultimediaExtensions() throws IOException {
            // Common audio formats
            assertEquals("audio/x-wav", mimeMap.getMimeType("wav"));
            // mp3 has multiple mappings, first one wins
            assertEquals("audio/x-mpegurl", mimeMap.getMimeType("mp3"));

            // Common video formats
            assertEquals("video/x-msvideo", mimeMap.getMimeType("avi"));

     *
     * @return broadcast address to use
     */
    InetAddress getBroadcastAddress();

    /**
     *
     *
     * Property {@code jcifs.netbios.wins} (string, comma separated)
     *
     * @return WINS server to use
     */
    InetAddress[] getWinsServers();

    /**
     *
     * Property {@code jcifs.netbios.lport} (int)
     *

      "FINE: Q10000 starting              : task",
      "FINE: Q10000 finished run in   0 µs: task",
    )
  }

  /** Repeat with a delay of 200 but schedule with a delay of 50. The schedule wins. */
  @Test fun executeScheduledEarlierReplacesRepeatedLater() {
    val task =
      object : Task("task") {
        val schedules = mutableListOf(50.µs)
        val delays = mutableListOf(200.µs, -1)

    // Start by looking for exact matches. We start at the leftmost label. For example, foo.bar.com
    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null
    for (i in domainLabelsUtf8Bytes.indices) {
      val rule = publicSuffixList.bytes.binarySearch(domainLabelsUtf8Bytes, i)
      if (rule != null) {
        exactMatch = rule

  /** If a cookie incorrectly defines multiple 'Max-Age' attributes, the last one defined wins.  */
  @Test fun lastMaxAgeWins() {
    assertThat(parseCookie(0L, url, "a=b; Max-Age=2; Max-Age=4; Max-Age=1; Max-Age=3")!!.expiresAt)
      .isEqualTo(3000L)
  }

  /** If a cookie incorrectly defines multiple 'Expires' attributes, the last one defined wins.  */
  @Test fun lastExpiresAtWins() {
    assertThat(
      parseCookie(

        assertEquals(engine2, scriptEngineFactory.getScriptEngine("engine2"));
        assertEquals(customEngine, scriptEngineFactory.getScriptEngine("custom"));

        // Verify class name access - last added engine of same class wins
        assertEquals(engine2, scriptEngineFactory.getScriptEngine("testscriptengine"));
        assertEquals(customEngine, scriptEngineFactory.getScriptEngine("customscriptengine"));
    }

   * - 2 requests happen concurrently to a host that can be coalesced onto a single connection.
   * - 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.

                } else { /* keep using the old list */
                    this.dcListExpiration = now + 1000 * 60 * 15; /* 15 min */
                    log.warn("Failed to retrieve DC list from WINS");
                }
            }

            final int max = Math.min(this.dcList.length, this.netbiosLookupRespLimit);
            for (int j = 0; j < max; j++) {

            List<ArtifactRepository> remoteRepositories,
            ArtifactRepository localRepository)
            throws RepositoryMetadataStoreException {
        // TODO currently this is first wins, but really we should take the latest by comparing either the
        // snapshot timestamp, or some other timestamp later encoded into the metadata.

        assertSame(broadcastAddr, resultBroadcastAddr, "Should delegate broadcast address");
        assertSame(winsServers, resultWinsServers, "Should delegate WINS servers");
        assertEquals(445, resultLocalPort, "Should delegate local port");

        verify(mockDelegate).getLocalAddr();
        verify(mockDelegate).getBroadcastAddress();