throw new PACDecodingException("Malformed PAC signature", e);
        }
    }

    /**
     * Gets the checksum type of this signature.
     *
     * @return the checksum type constant
     */
    public int getType() {
        return this.type;
    }

    /**
     * Gets the checksum data.
     *
     * @return the checksum bytes
     */
    public byte[] getChecksum() {

    }

    TypeMetaData getType() {
        return type
    }

    Element getDescription() {
        return blockMethod.description;
    }

    List<Element> getComment() {
        return blockMethod.comment
    }

    boolean isDeprecated() {
        return blockProperty.deprecated || blockMethod.deprecated
    }

    boolean isIncubating() {
        return blockProperty.incubating || blockMethod.incubating
    }

 * including navigation controls and search/filter parameters.
 *
 * <p>Duplicate hosts allow administrators to define hostname patterns that should
 * be treated as equivalent during crawling, helping to avoid duplicate content
 * from the same logical site accessed via different hostnames.</p>
 */
public class DuplicateHostPager implements Serializable {

    private static final long serialVersionUID = 1L;

    constructor(response: ResponseBody) : this(
      source = response.source(),
      boundary =
        response.contentType()?.parameter("boundary")
          ?: throw ProtocolException("expected the Content-Type to have a boundary parameter"),
    )

    @Throws(IOException::class)
    fun nextPart(): Part? {
      check(!closed) { "closed" }

      if (noMoreParts) return null

 * number called a <i>hash code</i>.
 *
 * <h3>Definition</h3>
 *
 * <p>Unpacking this definition:
 *
 * <ul>
 *   <li><b>block of data:</b> the input for a hash function is always, in concept, an ordered byte
 *       array. This hashing API accepts an arbitrary sequence of byte and multibyte values (via
 *       {@link Hasher}), but this is merely a convenience; these are always translated into raw

      return bytes;
    }

    @Override
    boolean equalsSameBits(HashCode that) {
      // We don't use MessageDigest.isEqual() here because its contract does not guarantee
      // constant-time evaluation (no short-circuiting).
      if (this.bytes.length != that.getBytesInternal().length) {
        return false;
      }

      boolean areEqual = true;

 * number called a <i>hash code</i>.
 *
 * <h3>Definition</h3>
 *
 * <p>Unpacking this definition:
 *
 * <ul>
 *   <li><b>block of data:</b> the input for a hash function is always, in concept, an ordered byte
 *       array. This hashing API accepts an arbitrary sequence of byte and multibyte values (via
 *       {@link Hasher}), but this is merely a convenience; these are always translated into raw

        goodCertificate.certificate,
      )
    server.useHttps(socketFactory)
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .addHeader("Content-Type: text/plain")
        .build(),
    )

    // Make a request from client to server. It should succeed certificate checks (unfortunately the
    // rogue CA is trusted) but it should fail certificate pinning.

import okhttp3.Request;
import okhttp3.Response;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;

/**
 * Create UNIX domain sockets for MockWebServer and OkHttp and connect 'em together. Note that we
 * cannot do TLS over domain sockets.
 */
public class ClientAndServer {
  public void run() throws Exception {
    File socketFile = new File("/tmp/ClientAndServer.sock");

        try {
            return new JarFile(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Returns an input stream to read the contents of the specified JAR file entry.
     *
     * @param file the JAR file (must not be {@literal null})
     * @param entry the JAR file entry (must not be {@literal null})
     * @return the input stream to read the entry