}

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  protected final boolean supportsValuesHashCode(Map<K, V> map) {
    // get the first non-null value
    Collection<V> values = map.values();
    for (V value : values) {
      if (value != null) {
        try {
          int unused = value.hashCode();
        } catch (Exception e) { // sneaky checked exception
          return false;
        }

      value > Int.MAX_VALUE -> Int.MAX_VALUE
      value < 0 -> 0
      else -> value.toInt()
    }
  } catch (_: NumberFormatException) {
    return defaultValue
  }
}

/** Closes this, ignoring any checked exceptions. */
fun Closeable.closeQuietly() {
  try {
    close()
  } catch (rethrown: RuntimeException) {
    throw rethrown
  } catch (_: Exception) {
  }
}

/**

        HTTP_TEMP_REDIRECT,
        -> {
          // These codes can only be cached with the right response headers.
          // http://tools.ietf.org/html/rfc7234#section-3
          // s-maxage is not checked because OkHttp is a private cache that should ignore s-maxage.
          if (response.header("Expires") == null &&
            response.cacheControl.maxAgeSeconds == -1 &&
            !response.cacheControl.isPublic &&

        final ServerMessageBlock msg = (ServerMessageBlock) m;

        if ((msg.getFlags2() & SmbConstants.FLAGS2_SECURITY_SIGNATURES) == 0) {
            // signature requirements need to be checked somewhere else
            log.warn("Expected signed response, but is not signed");
            return false;
        }

        update(this.macSigningKey, 0, this.macSigningKey.length);
        int index = offset;

	if t.staleUploadsCleanupInterval != cfg.StaleUploadsCleanupInterval {
		t.staleUploadsCleanupInterval = cfg.StaleUploadsCleanupInterval

		// signal that cleanup interval has changed
		select {
		case staleUploadsCleanupIntervalChangedCh <- struct{}{}:
		default: // in case the channel is blocked...
		}
	}
}

func (t *apiConfig) odirectEnabled() bool {
	t.mu.RLock()

            // We've exhausted our current label. Either there are more labels to compare, in which
            // case we expect a dot as the next character. Otherwise, we've checked all our labels.
            if (currentLabelIndex == labels.size - 1) {
              break
            } else {
              currentLabelIndex++
              currentLabelByteIndex = -1

        Map<String, Object> context = new HashMap<>();
        context.put("key1", "value1");
        context.put("key2", "value2");

        logger.logEvent(EventType.CONFIGURATION_CHANGE, Severity.INFO, "Configuration changed", context);

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.CONFIGURATION_CHANGE), "Should have 1 configuration event");
    }

    @Test

            assertEquals(specialMessage, exception.getMessage());
        });
    }

    @Test
    @DisplayName("Should handle different cause types")
    void testVariousCauseTypes() {
        // Test with checked exception
        Exception checkedException = new java.io.IOException("IO Error");
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException(checkedException);

        transaction.nextElement();
        byte initialCommand = transaction.command;

        // Second call - secondary
        transaction.nextElement();

        // Verify command changed to secondary
        assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION_SECONDARY, transaction.command,
                "Command should change to SMB_COM_TRANSACTION_SECONDARY");
    }

    @Test

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  public final boolean trySetAccessible() {
    // We can't call accessibleObject.trySetAccessible since that was added in Java 9 and this code
    // should work on Java 8. So we emulate it this way.
    try {
      accessibleObject.setAccessible(true);
      return true;
    } catch (Exception e) { // sneaky checked exception
      return false;
    }
  }