if err := feedTokens(1); err != nil {
		return nil, err
	}
	numEntries, err := strconv.ParseInt(nextToken(), 10, 0) // Intentionally parse as native int
	if err != nil || numEntries < 0 || int(2*numEntries) < int(numEntries) {
		return nil, ErrHeader
	}

	// Parse for all member entries.
	// numEntries is trusted after this since a potential attacker must have

        // Test size calculation
        int size = request.size();
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 32 + 64;
        int expectedSize = (expectedRawSize + 7) & ~7;
        assertEquals(expectedSize, size);

        // Test wire format writing
        byte[] buffer = new byte[512];
        int bytesWritten = request.writeBytesWireFormat(buffer, 64);

  @SuppressWarnings("unchecked") // safe covariant cast!
  @Override
  public UnmodifiableListIterator<E> listIterator(int index) {
    return (UnmodifiableListIterator<E>) delegateList.listIterator(index);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

  @Override

        private final byte[] buffer = new byte[20];
        private final int dataCompactionMode = 1;
        private final int dataLength = 1024;
        private final int dataOffset = 54;

        @BeforeEach
        public void setUp() {
            // Build a sample buffer
            int bufferIndex = 0;
            bufferIndex += 2; // reserved

        int status = NtStatus.NT_STATUS_OBJECT_NAME_NOT_FOUND;

        // When/Then
        assertEquals((int) 0xC0000034L, status);
        // Should be an error status (0xC prefix)
        assertTrue((status & (int) 0xC0000000L) == (int) 0xC0000000L);
    }

    @Test
    @DisplayName("Should handle sharing violation status")
    void testSharingViolationStatus() {
        // Given

            }
          }
        };

    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.peek());
    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.next());

    assertEquals(1, (int) iter.peek());
    assertEquals(1, (int) iter.next());

    /*

    return array;
  }

  @Override
  int internalArrayStart() {
    return 0;
  }

  @Override
  int internalArrayEnd() {
    return size;
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int dstOff) {
    arraycopy(array, 0, dst, dstOff, size);
    return dstOff + size;
  }

  // The fake cast to E is safe because the creation methods only allow E's
  @Override

     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 24);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt2(24, dst, dstIndex);

     */
    private static class TestBufferCacheImpl implements BufferCache {
        private final List<byte[]> cache;
        private final int bufferSize;
        private final int maxBuffers;

        public TestBufferCacheImpl(int maxBuffers, int bufferSize) {
            this.maxBuffers = maxBuffers;
            this.bufferSize = bufferSize;
            this.cache = new ArrayList<>(maxBuffers);
        }

  }

  @Override
  public int hashCode() {
    return getClass().hashCode() ^ seed;
  }

  @Override
  public HashCode hashInt(int input) {
    int k1 = mixK1(input);
    int h1 = mixH1(seed, k1);

    return fmix(h1, Ints.BYTES);
  }

  @Override
  public HashCode hashLong(long input) {
    int low = (int) input;
    int high = (int) (input >>> 32);

    int k1 = mixK1(low);