}

    @Override
    ImmutableMap<K, V> map() {
      return map;
    }

    @Override
    @GwtIncompatible("not used in GWT")
    int copyIntoArray(@Nullable Object[] dst, int offset) {
      return entries.copyIntoArray(dst, offset);
    }

    @Override
    public UnmodifiableIterator<Entry<K, V>> iterator() {
      return entries.iterator();
    }

    @Override
    @GwtIncompatible("Spliterator")

    void testReadParametersWireFormatWithBufferOffset() throws Exception {
        int offset = 20;
        byte[] notificationData = createSingleNotificationBuffer("offset_test.txt", FileNotifyInformation.FILE_ACTION_MODIFIED);
        byte[] buffer = new byte[offset + notificationData.length];
        System.arraycopy(notificationData, 0, buffer, offset, notificationData.length);

		objectName     string
		offset         int64
		expectedResult []byte
		expectErr      bool
	}{
		{"foo", "myobject", 0, []byte("foo"), false},
		{"foo", "myobject", 1, []byte("oo"), false},
		// file not found error.
		{"foo", "yourobject", 0, nil, true},
	}

	result := make([]byte, 100)
	for i, testCase := range testCases {
		result = result[testCase.offset:3]

     * @param str string to measure
     * @param offset current buffer offset for alignment calculation
     * @return string length
     */
    public int stringWireLength(final String str, final int offset) {
        int len = str.length() + 1;
        if (this.useUnicode) {
            len = str.length() * 2 + 2;
            len = offset % 2 != 0 ? len + 1 : len;
        }
        return len;
    }

            int charCount = str.length();

            // NDR string structure: MaximumCount, Offset, ActualCount, then data
            buf.enc_ndr_long(charCount + 1); // MaximumCount (including null terminator)
            buf.enc_ndr_long(0); // Offset
            buf.enc_ndr_long(charCount + 1); // ActualCount (including null terminator)

            // String data in UTF-16LE

    return new SubList(fromIndex, toIndex - fromIndex);
  }

  private final class SubList extends ImmutableList<E> {
    final transient int offset;
    final transient int length;

    SubList(int offset, int length) {
      this.offset = offset;
      this.length = length;
    }

    @Override
    public int size() {
      return length;
    }

    @Override

        byte[] buffer = new byte[256];
        int offset = 10;
        int size = 100;
        when(response.verifySignature(buffer, offset, size)).thenReturn(true);

        // When
        boolean verified = response.verifySignature(buffer, offset, size);

        // Then
        assertTrue(verified);
        verify(response).verifySignature(buffer, offset, size);
    }

    @Test

    private final Smb2RdmaTransform transform;

    /**
     * Create new RDMA channel info
     *
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure

     */
    int SECURITY_USER = 0x01;

    /**
     * Offset of command field in SMB header.
     */
    int CMD_OFFSET = 4;
    /**
     * Offset of error code field in SMB header.
     */
    int ERROR_CODE_OFFSET = 5;
    /**
     * Offset of flags field in SMB header.
     */
    int FLAGS_OFFSET = 9;
    /**
     * Offset of signature field in SMB header.
     */

    /** Number of parameter bytes in this response */
    protected int parameterCount;
    /** Offset from the start of the SMB header to the parameter bytes */
    protected int parameterOffset;
    /** Displacement of these parameter bytes from the start of the total parameter block */
    protected int parameterDisplacement;
    /** Offset from the start of the SMB header to the data bytes */
    protected int dataOffset;