void testDecode() throws NdrException {
        // Test the decode method
        long decodedValue = 112233445566778L;
        NdrHyper ndrHyper = new NdrHyper(0); // Initialize with a dummy value

        // Configure the mock NdrBuffer to return a specific value when dec_ndr_hyper is called
        when(mockNdrBuffer.dec_ndr_hyper()).thenReturn(decodedValue);

        // Call the decode method with the mocked NdrBuffer

        response = new Smb2QueryDirectoryResponse(mockConfig, (byte) 0x03);

        assertNull(response.getResults());
    }

    @Test
    @DisplayName("Test getResults returns decoded file entries")
    void testGetResultsReturnsDecodedEntries() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, (byte) 0x03);

        // Use reflection to set the results field

            if (this.netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.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;

    assertThat(UnsignedInts.decode("0xffffffff")).isEqualTo(0xffffffff);
    assertThat(UnsignedInts.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedInts.decode("#12345678")).isEqualTo(0x12345678);
    assertThat(UnsignedInts.decode("76543210")).isEqualTo(76543210);
    assertThat(UnsignedInts.decode("0x13579135")).isEqualTo(0x13579135);
    assertThat(UnsignedInts.decode("0X13579135")).isEqualTo(0x13579135);

    assertThat(UnsignedLongs.decode("0xffffffffffffffff")).isEqualTo(0xffffffffffffffffL);
    assertThat(UnsignedLongs.decode("01234567")).isEqualTo(01234567); // octal
    assertThat(UnsignedLongs.decode("#1234567890abcdef")).isEqualTo(0x1234567890abcdefL);
    assertThat(UnsignedLongs.decode("987654321012345678")).isEqualTo(987654321012345678L);
    assertThat(UnsignedLongs.decode("0x135791357913579")).isEqualTo(0x135791357913579L);

                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();
        }
    }

    the proxy selectors are different. Ugh!


## Version 4.2.0

_2019-09-10_

 *  New: API to decode a certificate and private key to create a `HeldCertificate`. This accepts a
    string containing both a certificate and PKCS #8-encoded private key.

    ```kotlin
    val heldCertificate = HeldCertificate.decode("""
        |-----BEGIN CERTIFICATE-----
        |MIIBYTCCAQegAwIBAgIBKjAKBggqhkjOPQQDAjApMRQwEgYDVQQLEwtlbmdpbmVl

        }

        @Test
        @DisplayName("Should decode sync message correctly")
        void testDecodeSync() throws SMBProtocolDecodingException {
            byte[] buffer = createValidSyncMessage();
            testMessage.setBytesRead(10);

            int len = testMessage.decode(buffer, 0);

            assertTrue(len > 0);
            assertFalse(testMessage.isAsync());

        SMBUtil.writeInt2(20, buffer, 42); // byteCount

        int length = testBlock.decode(buffer, 0);

        assertTrue(length > 0);
        assertEquals(4, testBlock.wordCount);
        assertNull(testBlock.getAndx());
    }

    @Test
    @DisplayName("Test decode with retain payload")
    void testDecodeWithRetainPayload() throws SMBProtocolDecodingException {

                _src = _src.deferred;
                root_directory.decode(_src);

            }
            if (_object_namep != 0) {
                if (object_name == null) { /* YOYOYO */
                    object_name = new rpc.unicode_string();
                }
                _src = _src.deferred;
                object_name.decode(_src);

            }
            if (_security_quality_of_servicep != 0) {