// delim.
func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {
	slice, err := b.readSlice(delim)
	// return a copy of slice. The buffer's backing array may
	// be overwritten by later calls.
	line = append(line, slice...)
	return line, err
}

// readSlice is like ReadBytes but returns a reference to internal buffer data.
func (b *Buffer) readSlice(delim byte) (line []byte, err error) {

</p>

<p>
The <code>SP</code> pseudo-register is a virtual stack pointer
used to refer to frame-local variables and the arguments being
prepared for function calls.
It points to the highest address within the local stack frame, so references should use negative offsets
in the range [−framesize, 0):
<code>x-8(SP)</code>, <code>y-4(SP)</code>, and so on.
</p>

<p>

      @Nullable Object value;
      @Nullable ValueHolder next;
    }

    /**
     * Holder object for values that cannot be null or empty (will be printed unconditionally). This
     * helps to shortcut most calls to isEmpty(), which is important because the check for emptiness
     * is relatively expensive. Use a subtype so this also doesn't need any extra storage.
     */

        assertTrue("process should be called", processCalled);
        assertEquals(testOrigin, processOrigin);
        assertEquals(response, processResponse);
    }

    // Test multiple process calls
    public void test_multipleProcessCalls() {
        HttpServletRequest request = createMockRequest();
        HttpServletResponse response = createMockResponse();

  public abstract boolean isVarArgs();

  /**
   * Invokes with {@code receiver} as 'this' and {@code args} passed to the underlying method and
   * returns the return value; or calls the underlying constructor with {@code args} and returns the
   * constructed instance.
   *
   * @throws IllegalAccessException if this {@code Constructor} object enforces Java language access

   *
   * @since 2.0
   */
  interface Entry<E extends @Nullable Object> {

    /**
     * Returns the multiset element corresponding to this entry. Multiple calls to this method
     * always return the same instance.
     *
     * @return the element corresponding to this entry
     */
    @ParametricNullness
    E getElement();

    /**

   * key {@code c}. If that row key / column key pair in not in {@code table}, the pair maps to
   * {@code null} in the generated table.
   *
   * <p>The returned table allows subsequent {@code put} calls with the row keys in {@code
   * table.rowKeySet()} and the column keys in {@code table.columnKeySet()}. Calling {@link #put}
   * with other keys leads to an {@code IllegalArgumentException}.
   *

        final NameQueryResponse response = new NameQueryResponse(this.transportContext.getConfig());

        if (addr != null) { /*
                             * UniAddress calls always use this
                             * because it specifies addr
                             */
            request.addr = addr; /* if addr ends with 255 flag it bcast */

            ACE ace = mock(ACE.class);
            when(ace.getAccessMask()).thenReturn(ACE.GENERIC_ALL);
            when(ace.isAllow()).thenReturn(true);

            // Multiple calls to same method
            ace.getAccessMask();
            ace.getAccessMask();

            // Different methods called
            ace.isAllow();
            ace.getFlags();

     */
    private const val MAX_QUEUE_SIZE = 16L * 1024 * 1024 // 16 MiB.

    /**
     * The maximum amount of time after the client calls [close] to wait for a graceful shutdown. If
     * the server doesn't respond the web socket will be canceled.
     */
    const val CANCEL_AFTER_CLOSE_MILLIS = 60L * 1000

    /**