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

        // Verify - with sectPerAlloc = 1, capacity = alloc * bytesPerSect
        assertEquals(alloc * bytesPerSect, smbInfoAllocation.getCapacity());
        assertEquals(free * bytesPerSect, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test decode with large bytes per sector")

    }

    @ParameterizedTest(name = "decode({1}) -> {2}")
    @MethodSource("decodeProvider")
    void testDecode(String encoded, byte[] expected) {
        // Act
        byte[] actual = Base64.decode(encoded);
        // Assert
        assertArrayEquals(expected, actual, "Base64.decode should return original bytes");
    }

    @Test
    @DisplayName("encode should throw NPE on null input")
    void testEncodeNull() {

        // The actual implementation reassigns _dst = _dst.deferred inside encode(), so we can't verify the exact buffer
        verify(objAttr.root_directory).encode(any(NdrBuffer.class));
        verify(objAttr.object_name).encode(any(NdrBuffer.class));
        verify(objAttr.security_quality_of_service).encode(any(NdrBuffer.class));
    }

    @Test

                    this.info = new DfsEnumStruct();
                }
                this.info.decode(_src);

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

            }
            this.retval = _src.dec_ndr_long();
        }
    }

    }

    /**
     * Decodes a security descriptor from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @return the number of bytes decoded
     * @throws SMBProtocolDecodingException if the data cannot be properly decoded
     */
    @Override

/**
 * Interface for objects that can be decoded from a byte buffer.
 * This interface provides methods for deserializing data from SMB protocol messages.
 *
 * @author mbechler
 */
public interface Decodable {

    /**
     * Decode data from a byte buffer
     *
     * @param buffer the byte buffer containing the data to decode
     * @param bufferIndex the starting index in the buffer

    }

    /**
     * Decodes the given host string using the specified encoding.
     *
     * @param host the host string to decode
     * @return the decoded host string
     */
    protected String decode(final String host) {
        if (host.indexOf('%') == -1) {
            return host;
        }
        try {
            return URLDecoder.decode(host, encoding);

    }

    @Test
    void testEncode() throws NdrException {
        // Test the encode method
        long testValue = 987654321098765L;
        NdrHyper ndrHyper = new NdrHyper(testValue);

        // Call the encode method with the mocked NdrBuffer
        ndrHyper.encode(mockNdrBuffer);

        // Verify that enc_ndr_hyper was called exactly once with the correct value

            // Setup for SamrSamEntry decode chain
            mockDeferredBuffer.deferred = mockDeferredBuffer;
            when(mockDeferredBuffer.dec_ndr_short()).thenReturn(0, 0, 0);

            // When: Decoding output
            message.decode_out(mockNdrBuffer);

            // Then: Should decode all output parameters
            verify(samArray).decode(mockNdrBuffer);

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(this.sid, 1);

            if (this.sid != null) {
                _dst = _dst.deferred;
                this.sid.encode(_dst);

            }
        }

        @Override
        public void decode(NdrBuffer _src) throws NdrException {