}

  @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`() {

            assertEquals(FileSystemInformation.FS_FULL_SIZE_INFO, fileFsFullSizeInfo.getFileSystemInformationClass());
        }
    }

    @Nested
    @DisplayName("Decode Method Tests")
    class DecodeMethodTests {

        @Test
        @DisplayName("Should decode buffer with typical values correctly")
        void shouldDecodeBufferWithTypicalValues() throws SMBProtocolDecodingException {

            verify(mockNdrBuffer).enc_ndr_small((byte) 0xFF);
        }

        @Test
        @DisplayName("Should decode UUID correctly")
        void testUuidTDecode() throws NdrException {
            // Given: A UUID object to decode into
            rpc.uuid_t uuid = new rpc.uuid_t();

            // Mock the NdrBuffer responses for decoding

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

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

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

            }

            // 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);

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

        }

        @Test
        @DisplayName("Should inherit decode from Decodable")
        void shouldInheritDecodeMethod() throws NoSuchMethodException {
            // Verify method is inherited
            assertNotNull(AllocInfo.class.getMethod("decode", byte[].class, int.class, int.class));
            assertEquals(int.class, AllocInfo.class.getMethod("decode", byte[].class, int.class, int.class).getReturnType());
        }

        // Test decode
        int size = ace.decode(testBuffer, 0, testBuffer.length);

        // Verify results
        assertEquals(32, size);
        assertTrue(ace.isAllow());
        assertEquals(0x03, ace.getFlags());
        assertEquals(0x001200A9, ace.getAccessMask());
        assertNotNull(ace.getSID());
    }

    @Test
    @DisplayName("Test decode with deny ACE")

    @Test
    @DisplayName("Should define decode method")
    void testDecodeMethod() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[10];
        int bufferIndex = 0;
        int len = 10;
        when(mockDecodable.decode(buffer, bufferIndex, len)).thenReturn(10);

        // When
        int decodedLength = mockDecodable.decode(buffer, bufferIndex, len);

        // Then