super(CHUNK_SIZE);
      this.h1 = seed;
      this.h2 = seed;
      this.length = 0;
    }

    @Override
    protected void process(ByteBuffer bb) {
      long k1 = bb.getLong();
      long k2 = bb.getLong();
      bmix64(k1, k2);
      length += CHUNK_SIZE;
    }

    private void bmix64(long k1, long k2) {
      h1 ^= mixK1(k1);

      h1 = Long.rotateLeft(h1, 27);
      h1 += h2;

    if (usingVarHandle != null) {
      return usingVarHandle;
    }

    try {
      /*
       * UnsafeByteArray uses Unsafe.getLong() in an unsupported way, which is known to cause
       * crashes on Android when running in 32-bit mode. For maximum safety, we shouldn't use
       * Unsafe.getLong() at all, but the performance benefit on x86_64 is too great to ignore, so

      this.v0 ^= k0;
      this.v1 ^= k1;
      this.v2 ^= k0;
      this.v3 ^= k1;
    }

    @Override
    protected void process(ByteBuffer buffer) {
      b += CHUNK_SIZE;
      processM(buffer.getLong());
    }

    @Override
    protected void processRemaining(ByteBuffer buffer) {
      b += buffer.remaining();
      for (int i = 0; buffer.hasRemaining(); i += 8) {

        assertTrue(Modifier.isPrivate(serialVersionField.getModifiers()));
        serialVersionField.setAccessible(true);
        assertEquals(1L, serialVersionField.getLong(null));
    }

    /**
     * Test that all label constants follow the naming convention
     */
    public void test_labelConstantsNamingConvention() throws Exception {

    private long getSerialVersionUID() {
        try {
            java.lang.reflect.Field field = FessMessages.class.getDeclaredField("serialVersionUID");
            field.setAccessible(true);
            return field.getLong(null);
        } catch (Exception e) {
            fail("Failed to get serialVersionUID: " + e.getMessage());
            return -1;
        }
    }

    // Test error message methods without parameters

    checkArgument(
        buffer.remaining() >= BYTES,
        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    return new Stats(
        buffer.getLong(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble());
  }

  private static final long serialVersionUID = 0;

    }
    return result;
  }

  /**
   * Returns the {@code long} value whose big-endian representation is stored in the first 8 bytes
   * of {@code bytes}; equivalent to {@code ByteBuffer.wrap(bytes).getLong()}. For example, the
   * input byte array {@code {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19}} would yield the
   * {@code long} value {@code 0x1213141516171819L}.
   *

      addressAsLong = getEmbeddedIPv4ClientAddress(ip6).hashCode();
    } else {
      // Just extract the high 64 bits (assuming the rest is user-modifiable).
      addressAsLong = ByteBuffer.wrap(ip6.getAddress(), 0, 8).getLong();
    }

    // Many strategies for hashing are possible. This might suffice for now.
    int coercedHash = Hashing.murmur3_32_fixed().hashLong(addressAsLong).asInt();

      addressAsLong = getEmbeddedIPv4ClientAddress(ip6).hashCode();
    } else {
      // Just extract the high 64 bits (assuming the rest is user-modifiable).
      addressAsLong = ByteBuffer.wrap(ip6.getAddress(), 0, 8).getLong();
    }

    // Many strategies for hashing are possible. This might suffice for now.
    int coercedHash = Hashing.murmur3_32_fixed().hashLong(addressAsLong).asInt();

import org.jspecify.annotations.Nullable;

/** Unit tests for {@link Futures#getDone}. */
@GwtCompatible
@NullUnmarked
public class FuturesGetDoneTest extends TestCase {
  public void testSuccessful() throws ExecutionException {
    assertThat(getDone(immediateFuture("a"))).isEqualTo("a");
  }

  public void testSuccessfulNull() throws ExecutionException {
    assertThat(getDone(Futures.<@Nullable String>immediateFuture(null))).isEqualTo(null);
  }