final class Hashing {
  private Hashing() {}

  /*
   * These should be ints, but we need to use longs to force GWT to do the multiplications with
   * enough precision.
   */
  private static final long C1 = 0xcc9e2d51;
  private static final long C2 = 0x1b873593;

  /*
   * This method was rewritten in Java from an intermediate step of the Murmur hash function in

    }

    @Override
    public long getExpiration() {
        handshake();
        return this.connection.getExpiration();
    }

    @Override
    public long getDate() {
        handshake();
        return this.connection.getDate();
    }

    @Override
    public long getLastModified() {
        handshake();

 * signatures.
 *
 * @param codePointLimit the number of code points to read in order to make a decision.
 */
internal fun BufferedSource.isProbablyUtf8(codePointLimit: Long = Long.MAX_VALUE): Boolean {
  try {
    val peek = peek()
    for (i in 0 until codePointLimit) {
      if (peek.exhausted()) {
        break
      }
      val codePoint = peek.readUtf8CodePoint()

    protected final int localKey;
    /** Remote key for remote RDMA access */
    protected final int remoteKey;
    /** Virtual address of the memory region */
    protected final long address;
    /** Flag indicating if the memory region is still valid */
    protected volatile boolean valid;

    /**
     * Create new RDMA memory region
     *
     * @param buffer memory buffer to register

        assertEquals(Constants.HEAD_METHOD, response.getMethod());
    }

    static class TestClient implements CrawlerClient {
        int count;

        int exceptionCount;

        long interval = 500;

        long previousTime;

        @Override
        public void setInitParameterMap(final Map<String, Object> params) {
        }

        /*
         * (non-Javadoc)
         *

        }

        @Override
        public long createTime() {
            return 0;
        }

        @Override
        public long lastModified() {
            return 0;
        }

        @Override
        public long lastAccess() {
            return 0;
        }

        @Override
        public long length() {
            return 0;
        }

    assertThat(identity.apply(null)).isNull();
    assertSame("foo", identity.apply("foo"));
  }

  public void testIdentity_notSame() {
    Function<Long, Long> identity = Functions.identity();
    assertNotSame(new Long(135135L), identity.apply(new Long(135135L)));
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testIdentitySerializable() {

        dos.writeInt(Integer.reverseBytes(value));
    }

    private void writeLittleEndianLong(DataOutputStream dos, long value) throws IOException {
        dos.writeLong(Long.reverseBytes(value));
    }

    @Test
    @DisplayName("Test parsing with invalid data size")
    void testInvalidDataSize() {
        byte[] tooSmall = new byte[10];

     * the one provided will not be returned if it exceeds the end of the file
     * (if this is a problem let us know).
     */
    @Override
    public long skip(final long n) throws IOException {
        if (n > 0) {
            fp += n;
            return n;
        }
        return 0;
    }

 * It extends ExtractException and indicates that the requested extraction operation cannot be performed.
 *
 */
public class UnsupportedExtractException extends ExtractException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructor.
     * @param message The error message.
     */
    public UnsupportedExtractException(final String message) {
        super(message, false, false);
    }