* readAndXWireFormat without reading the non-existent header.
     */

    @Override
    int decode(final byte[] buffer, int bufferIndex) {
        final int start = headerStart = bufferIndex;

        bufferIndex += readHeaderWireFormat(buffer, bufferIndex);
        bufferIndex += readAndXWireFormat(buffer, bufferIndex);

        length = bufferIndex - start;
        return length;
    }

        buffer.putInt(0); // nextEntryOffset (0 = last entry)
        buffer.putInt(FileNotifyInformation.FILE_ACTION_MODIFIED);
        buffer.putInt(fileNameBytes3.length);
        buffer.put(fileNameBytes3);

        // Return only the used portion of the buffer
        byte[] result = new byte[buffer.position()];
        buffer.rewind();
        buffer.get(result);
        return result;
    }

        SMBUtil.writeInt4(2, buffer, notifyOffset + 4); // Action (REMOVED)
        SMBUtil.writeInt4(10, buffer, notifyOffset + 8);
        System.arraycopy("file2".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 10);

        // Third notification at offset 164 (120 + 44)
        notifyOffset = 164;
        SMBUtil.writeInt4(0, buffer, notifyOffset); // NextEntryOffset (last)

    int slen = s.length();

    // Get a destination buffer and setup some loop variables.
    char[] dest = Platform.charBufferFromThreadLocal();
    int destSize = dest.length;
    int destIndex = 0;
    int lastEscape = 0;

    // Loop through the rest of the string, replacing when needed into the
    // destination buffer, which gets grown as needed as well.
    for (; index < slen; index++) {

            final int lLow = SMBUtil.readInt4(buffer, bufferIndex + 16);

            this.lengthInBytes = lHigh << 32 | lLow;
            return 20;
        }
        this.pid = SMBUtil.readInt2(buffer, bufferIndex);
        this.byteOffset = SMBUtil.readInt4(buffer, bufferIndex + 2);
        this.lengthInBytes = SMBUtil.readInt4(buffer, bufferIndex + 6);
        return 10;
    }

import com.google.common.annotations.J2ktIncompatible;
import java.nio.Buffer;

/**
 * Wrappers around {@link Buffer} methods that are covariantly overridden in Java 9+. See
 * https://github.com/google/guava/issues/3990
 */
@J2ktIncompatible
@GwtIncompatible
final class Java8Compatibility {
  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

        @Override
        public String toString() {
            StringBuilder buffer = new StringBuilder();
            for (Item item : this) {
                if (!buffer.isEmpty()) {
                    buffer.append((item instanceof ListItem) ? '-' : '.');
                }
                buffer.append(item);
            }
            return buffer.toString();
        }

        /**

        byte[] buffer = new byte[512];
        int bufferIndex = 0;

        // Set structure size to 9 (valid)
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set buffer offset (relative to header start)
        SMBUtil.writeInt2(80, buffer, bufferIndex + 2);
        // Set buffer length (empty directory)
        SMBUtil.writeInt4(0, buffer, bufferIndex + 4);

    }

    @Test
    @DisplayName("Test constructor with buffer decodes correctly")
    void testConstructorWithBuffer() throws IOException {
        // Create test buffer with notification data
        byte[] buffer = createValidNotificationBuffer("testfile.txt", FileNotifyInformation.FILE_ACTION_ADDED);

        FileNotifyInformationImpl info = new FileNotifyInformationImpl(buffer, 0, buffer.length);

        assertNotNull(info);

            byte[] buffer = new byte[24];
            buffer[4] = 0x04; // sectPerAlloc = 4
            buffer[8] = 0x00;
            buffer[9] = 0x20; // alloc = 8192
            buffer[16] = 0x00;
            buffer[17] = 0x04; // bytesPerSect = 1024

            smbInfoAllocation.decode(buffer, 0, buffer.length);