* doing so would be to derive a separate test library by using remove_from_jar to strip out
   * ClassValueValidator.
   *
   * Fortunately, we get pretty good coverage "by accident": We run all these tests against the
   * *backport*, where ClassValueValidator is not present.
   */

   * doing so would be to derive a separate test library by using remove_from_jar to strip out
   * ClassValueValidator.
   *
   * Fortunately, we get pretty good coverage "by accident": We run all these tests against the
   * *backport*, where ClassValueValidator is not present.
   */

        when(httpSession.getAttribute("NtlmHttpChal")).thenReturn(null);

        // For this test, we'll simulate that no auth header means we should challenge
        // Since we can't mock the internal transport operations easily without real network,
        // we'll test the simpler case where no NTLM negotiation is needed
        when(request.getHeader("Authorization")).thenReturn(null);

    # blocking __exit__ from running waiting on a free thread
    # can create race conditions/deadlocks if the context manager itself
    # has its own internal pool (e.g. a database connection pool)
    # to avoid this we let __exit__ run without a capacity limit
    # since we're creating a new limiter for each call, any non-zero limit
    # works (1 is arbitrary)
    exit_limiter = CapacityLimiter(1)
    try:

  public MapMaker concurrencyLevel(int concurrencyLevel) {
    checkArgument(
        concurrencyLevel >= 1, "concurrency level (%s) must be at least 1", concurrencyLevel);
    // GWT technically only supports concurrencyLevel == 1, but we silently
    // ignore other positive values.
    return this;
  }

  public <K, V> ConcurrentMap<K, V> makeMap() {
    return new ConcurrentHashMap<K, V>(initialCapacity);
  }

            test.onlyIf((t) -> Util.getBooleanProperty("tests.fips.enabled", false) == false);
            test.setMaxParallelForks(defaultParallel);
        });
        // we put all our distributable files under distributions
        project.getTasks().withType(Jar.class).configureEach(j ->
                j.getDestinationDirectory().set(new File(project.getBuildDir(), "distributions"))
        );

import org.jspecify.annotations.Nullable;

/**
 * An immutable object that may contain a non-null reference to another object. Each instance of
 * this type either contains a non-null reference, or contains nothing (in which case we say that
 * the reference is "absent"); it is never said to "contain {@code null}".
 *
 * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable {@code T}

  }

  private boolean allBmp(String string) {
    // Ordinarily we'd use something like i += Character.charCount(string.codePointAt(i)) here. But
    // we can get away with i++ because the whole point of this method is to return false if we find
    // a code point that doesn't fit in a char.
    for (int i = 0; i < string.length(); i++) {
      if (string.codePointAt(i) > 0xffff) {
        return false;
      }

 */

plugins {
    id("io.gitlab.arturbosch.detekt")
}

detekt {
    // enable all default rules
    buildUponDefaultConfig = true

    // customize some of the rules, until we can fix the offending cases
    config.convention(project.isolated.rootProject.projectDirectory.file("gradle/detekt.yml"))

    // also check the project build file
    source.from(project.buildFile)
}

import okio.BufferedSink
import okio.GzipSink
import okio.buffer

internal class GzipRequestBody(
  val delegate: RequestBody,
) : RequestBody() {
  override fun contentType() = delegate.contentType()

  // We don't know the compressed length in advance!
  override fun contentLength() = -1L

  override fun writeTo(sink: BufferedSink) {
    GzipSink(sink).buffer().use(delegate::writeTo)
  }