val requestLineString = socket.source.readUtf8LineStrict()
      if (requestLineString.isEmpty()) {
        throw ProtocolException("no request because the stream is exhausted")
      }
      request = decodeRequestLine(requestLineString)

      while (true) {
        val header = socket.source.readUtf8LineStrict()
        if (header.isEmpty()) {
          break
        }
        addHeaderLenient(headers, header)

                    keysByAlgo.put(key.getKeyType(), key);
                }

                KerberosKey serverKey = keysByAlgo.get(encType.getValue().intValue());
                if (keysByAlgo.isEmpty() || serverKey == null) {
                    throw new PACDecodingException("Kerberos key not found for eType " + encType.getValue());
                }

                try {

      assertFalse(testInstance.containsValue("blah"));
    }
  }

  public void testIsEmpty() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {
      assertFalse(testInstance.isEmpty());
    }
  }

  public void testForCells() {
    assertTrue(RegularImmutableTable.forCells(CELLS) instanceof DenseImmutableTable<?, ?, ?>);
    assertTrue(
        RegularImmutableTable.forCells(

    assertEmpty(result);
    assertEquals(0, result.size());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testGetNonEmpty() {
    Collection<V> result = multimap().get(k0());
    assertFalse(result.isEmpty());
    assertContentsAnyOrder(result, v0());
  }

  @CollectionSize.Require(SEVERAL)
  public void testGetMultiple() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v2()));

        String base = basedir.getAbsolutePath();
        if (path.startsWith(base)) {
            path = chopLeadingFileSeparator(path.substring(base.length()));
        }

        if (path.isEmpty()) {
            path = ".";
        }

        if (!new File(path).isAbsolute()) {
            path = path.replace('\\', '/');
        }

        return path;
    }

            if (!safe) {
                throw e;
            }
        }
    }

    private boolean isSpecificVersion(String version) {
        return !((version == null || version.isEmpty()) || version.startsWith("[") || version.startsWith("("));
    }

    // TODO !![jc; 28-jul-2005] check this; if we're using '-r' and there are aggregator tasks, this will result in
    // weirdness.

  }
}

fun CookieJar.receiveHeaders(
  url: HttpUrl,
  headers: Headers,
) {
  if (this === CookieJar.NO_COOKIES) return

  val cookies = Cookie.parseAll(url, headers)
  if (cookies.isEmpty()) return

  saveFromResponse(url, cookies)
}

/**
 * Returns true if the response headers and status indicate that this response has a (possibly
 * 0-length) body. See RFC 7231.
 */

    static boolean matchesLayout(String repoLayout, String mirrorLayout) {
        boolean result = false;

        // simple checks first to short circuit processing below.
        if ((mirrorLayout == null || mirrorLayout.isEmpty()) || WILDCARD.equals(mirrorLayout)) {
            result = true;
        } else if (mirrorLayout.equals(repoLayout)) {
            result = true;
        } else {
            // process the list

                incrementalVersion = null;
                buildNumber = null;
            }
        }
    }

    private static boolean isDigits(String cs) {
        if (cs == null || cs.isEmpty()) {
            return false;
        }
        final int sz = cs.length();
        for (int i = 0; i < sz; i++) {
            if (!Character.isDigit(cs.charAt(i))) {
                return false;

        // -------------------------------------------------------------------------------------

        String path = System.getProperty(altLocationSysProp);

        if (path == null || path.isEmpty()) {
            // TODO This replacing shouldn't be necessary as user.home should be in the
            // context of the container and thus the value would be interpolated by Plexus