!item.equals(NotAnInstance.EQUAL_TO_NOTHING));
      assertTrue(item + " must be Object#equals to itself", item.equals(item));
      assertEquals(
          "the Object#hashCode of " + item + " must be consistent",
          item.hashCode(),
          item.hashCode());
      if (!(item instanceof String)) {
        assertTrue(
            item + " must not be Object#equals to its Object#toString representation",

            // from being reused. Otherwise we're still obligated to transmit the request body to
            // leave the connection in a consistent state.
            exchange.noNewExchangesOnConnection()
          }
        }
      } else if (!isUpgradeRequest) {
        exchange.noRequestBody()
      }

 * equality for both keys and values. This may not be the desired behavior for map implementations
 * that use non-standard notions of key equality, such as the entry of a {@code SortedMap} whose
 * comparator is not consistent with {@code equals}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the
 * methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman

        assertNotNull(rp);
        assertEquals(name, rp.name(), "name() must match input");
        assertEquals(name, rp.toString(), "toString() should default to name()");
        // Ordinal is consistent with declaration order
        switch (name) {
        case "NONE":
            assertEquals(0, rp.ordinal());
            break;
        case "NO_TIMEOUT":
            assertEquals(1, rp.ordinal());

   *       traffic to {@code charlie}, rather than letting {@code bravo} keep its traffic.
   * </ul>
   *
   * <p>See the <a href="http://en.wikipedia.org/wiki/Consistent_hashing">Wikipedia article on
   * consistent hashing</a> for more information.
   */
  public static int consistentHash(HashCode hashCode, int buckets) {
    return consistentHash(hashCode.padToLong(), buckets);
  }

  /**

		wantOk       bool
	}{
		{
			name:         "consistent",
			m:            metaCacheEntries{inputSerialized[0], inputSerialized[0], inputSerialized[0], inputSerialized[0]},
			r:            metadataResolutionParams{dirQuorum: 4, objQuorum: 4, strict: false},
			wantSelected: &inputSerialized[0],
			wantOk:       true,
		},
		{
			name:         "consistent-strict",

            this.cachedSubject = s;
            return this.cachedSubject;
        } catch (LoginException e) {
            log.error("Failed to create login context", e);
            // Cache null to ensure consistent behavior across calls
            this.cachedSubject = null;
            return null;
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbRenewableCredentials#renew()

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

    /**
     * Sorts both the current inputs and new inputs arrays in place.
     * This ensures consistent ordering for comparison and equality operations.
     */
    public void sort() {
        if (inputs != null) {
            Arrays.sort(inputs);
        }
        if (newInputs != null) {

import javax.net.ssl.SSLException
import javax.net.ssl.SSLSession
import okhttp3.internal.canParseAsIpAddress
import okhttp3.internal.toCanonicalHost
import okio.utf8Size

/**
 * A HostnameVerifier consistent with [RFC 2818][rfc_2818].
 *
 * [rfc_2818]: http://www.ietf.org/rfc/rfc2818.txt
 */
@Suppress("NAME_SHADOWING")
object OkHostnameVerifier : HostnameVerifier {
  private const val ALT_DNS_NAME = 2

            // Then
            assertEquals(443, httpsPort);
            assertNotEquals(jcifs.smb1.http.Handler.DEFAULT_HTTP_PORT, httpsPort);
        }

        @Test
        @DisplayName("Should return consistent port value")
        void testPortConsistency() {
            // When
            int port1 = handler.getDefaultPort();
            int port2 = handler.getDefaultPort();
            int port3 = handler.getDefaultPort();