}

    @Test
    @DisplayName("Test decode with valid single entry")
    void testDecodeValidSingleEntry() throws SMBProtocolDecodingException {
        String fileName = "document.pdf";
        int action = FileNotifyInformation.FILE_ACTION_MODIFIED;
        byte[] buffer = createValidNotificationBuffer(fileName, action);

        int bytesRead = notifyInfo.decode(buffer, 0, buffer.length);

        assertTrue(bytesRead > 0);

which are unordered by happens before
(that is, neither <i>r</i> happens before <i>w</i>
nor <i>w</i> happens before <i>r</i>).
</p>

<p>
A <i>write-write data race</i> on memory location <i>x</i>
consists of two write-like memory operations <i>w</i> and <i>w'</i> on <i>x</i>,
at least one of which is non-synchronizing,
which are unordered by happens before.
</p>

<p>

            if (netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(netname);

            }
        }

        @Override
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);
            final int _netnamep = _src.dec_ndr_long();

            if (_netnamep != 0) {
                _src = _src.deferred;

                if (info == null) { /* YOYOYO */
                    info = new DfsEnumStruct();
                }
                info.decode(_src);

            }
            final int _totalentriesp = _src.dec_ndr_long();
            if (_totalentriesp != 0) {
                totalentries.decode(_src);

            }
            retval = _src.dec_ndr_long();
        }
    }

  }

  @Test fun `cannot decode malformed utc time`() {
    val bytes = "170d3139313231362333303231305a".decodeHex()
    assertFailsWith<ProtocolException> {
      Adapters.UTC_TIME.fromDer(bytes)
    }.also { expected ->
      assertThat(expected).hasMessage("Failed to parse UTCTime 191216#30210Z")
    }
  }

  @Test fun `cannot decode generalized time with offset`() {

        // Then
        assertEquals(expectedLength, actualLength);
        verify(messageBlock).decode(buffer, bufferIndex);
    }

    @Test
    @DisplayName("Test decode method throws SMBProtocolDecodingException")
    void testDecodeThrowsException() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[10];
        int bufferIndex = 0;

		buf.Reset()

		for _, outputRecord := range outputQueue {
			if outputRecord == nil {
				continue
			}
			before := buf.Len()
			if err = s3Select.marshal(buf, outputRecord); err != nil {
				bufPool.Put(buf)
				return false
			}
			if buf.Len()-before > maxRecordSize {
				writer.FinishWithError("OverMaxRecordSize", "The length of a record in the input or result is greater than maxCharsPerRecord of 1 MB.")

        // Use the encoded buffer for decoding
        NdrBuffer src = new NdrBuffer(encodeBuffer, 0);
        netdfs.DfsInfo1 decodedInfo1 = new netdfs.DfsInfo1();
        decodedInfo1.decode(src);

        assertEquals(info1.entry_path, decodedInfo1.entry_path);
    }

    @Test
    void testDfsInfo1_EncodeDecode_NullEntryPath() throws NdrException {
        netdfs.DfsInfo1 info1 = new netdfs.DfsInfo1();

        }

        @Test
        @DisplayName("Should decode buffer correctly")
        void testDecode() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[100];
            when(mockFileSystemInfo.decode(any(byte[].class), anyInt(), anyInt())).thenReturn(24);

            int result = mockFileSystemInfo.decode(buffer, 0, 100);

            assertEquals(24, result);

    }

    @Test
    @DisplayName("Test decode method with valid buffer")
    void testDecode() throws SMBProtocolDecodingException {
        // Prepare buffer with known value
        long expectedValue = 0x0123456789ABCDEFL;
        byte[] buffer = new byte[16];
        SMBUtil.writeInt8(expectedValue, buffer, 0);

        // Decode
        int bytesRead = fileInfo.decode(buffer, 0, buffer.length);