}

    /**
     * Parameterised test for a selection of edge and typical values.
     */
    @ParameterizedTest(name = "Encode and decode {0}")
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE })
    public void testEncodeWithVariousValues(long val) throws NdrException {
        NdrHyper hyper = new NdrHyper(val);
        // Create buffer with extra space for alignment

        .build(),
    )
    val webSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen() as RealWebSocket
    Thread.sleep(1000)

    // No pings and no pongs.
    assertThat(webSocket.sentPingCount()).isEqualTo(0)
    assertThat(webSocket.receivedPingCount()).isEqualTo(0)
    assertThat(webSocket.receivedPongCount()).isEqualTo(0)
    assertThat(server.sentPingCount()).isEqualTo(0)

import static java.lang.Byte.toUnsignedInt;
import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.common.primitives.Chars;
import com.google.common.primitives.Ints;
import com.google.common.primitives.Longs;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.Immutable;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

    @Nested
    @DisplayName("Edge Cases and Boundary Tests")
    class EdgeCasesTests {

        @ParameterizedTest
        @DisplayName("Should handle boundary values for capacity")
        @ValueSource(longs = { 0L, 1L, -1L, 1024L, 1048576L, 1073741824L, Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE - 1,
                Long.MIN_VALUE + 1 })
        void shouldHandleBoundaryValuesForCapacity(long capacity) {
            // Given

    List<Long> longs = Arrays.asList(0L, 1L, 2L);
    List<Double> doubles = Arrays.asList(0.0, 1.0, 2.0);

    assertThat(Bytes.toArray(bytes)).isEqualTo(array);
    assertThat(Bytes.toArray(shorts)).isEqualTo(array);
    assertThat(Bytes.toArray(ints)).isEqualTo(array);
    assertThat(Bytes.toArray(floats)).isEqualTo(array);
    assertThat(Bytes.toArray(longs)).isEqualTo(array);

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
   */
  public static Stats of(long... values) {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);
    return accumulator.snapshot();

    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
   */
  public void addAll(long... values) {
    for (long value : values) {
      add(value);
    }
  }

  /**

        // Verify through toString that value is set
        assertTrue(info.toString().contains("endOfFile=" + endOfFile));
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, 100L, 1024L, Long.MAX_VALUE, -1L, Long.MIN_VALUE })
    @DisplayName("Test constructor with various end of file values")
    void testConstructorWithVariousValues(long endOfFile) {

   */
  protected void processRemaining(ByteBuffer bb) {
    Java8Compatibility.position(bb, bb.limit()); // move at the end
    Java8Compatibility.limit(bb, chunkSize + 7); // get ready to pad with longs
    while (bb.position() < chunkSize) {
      bb.putLong(0);
    }
    Java8Compatibility.limit(bb, chunkSize);
    Java8Compatibility.flip(bb);
    process(bb);
  }

  @Override
  @CanIgnoreReturnValue

      return false;
    }

    @Override
    public int hashCode() {
      return SequentialFunnel.class.hashCode() ^ elementFunnel.hashCode();
    }
  }

  /**
   * Returns a funnel for longs.
   *
   * @since 13.0
   */
  public static Funnel<Long> longFunnel() {
    return LongFunnel.INSTANCE;
  }

  private enum LongFunnel implements Funnel<Long> {
    INSTANCE;

    @Override