}

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

     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {
        this.decode(buffer, bufferIndex, len);
    }

    /**
     * Decodes a security descriptor from a byte buffer.
     *

            // When/Then: Should throw NdrException
            assertThrows(NdrException.class, () -> policyHandle.encode(mockNdrBuffer));
        }

        @Test
        @DisplayName("Should decode policy handle correctly")
        void testPolicyHandleDecode() throws NdrException {
            // Given: A policy handle to decode into
            rpc.policy_handle policyHandle = new rpc.policy_handle();

      name = "BOOLEAN",
      tagClass = DerHeader.TAG_CLASS_UNIVERSAL,
      tag = 1L,
      codec =
        object : BasicDerAdapter.Codec<Boolean> {
          override fun decode(reader: DerReader): Boolean = reader.readBoolean()

          override fun encode(
            writer: DerWriter,
            value: Boolean,
          ) = writer.writeBoolean(value)
        },
    )

  val INTEGER_AS_LONG =
    BasicDerAdapter(

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

        // Verify - the decode method strips null termination, so filename should match
        assertEquals(expectedFilename, fileBothDirectoryInfo.getFilename());
    }

    @Test
    @DisplayName("Test decode with null-terminated non-Unicode filename")

    }

    @Test
    @DisplayName("Test decode with minimum valid length")
    void testDecodeMinimumValidLength() throws SMBProtocolDecodingException {
        // Prepare minimum valid buffer - exactly 24 bytes
        byte[] buffer = new byte[28];
        Arrays.fill(buffer, 0, 24, (byte) 0xAA);

        // Decode with len = 24 (minimum valid)
        int bytesConsumed = response.decode(buffer, 0, 24);

        byte[] dst = new byte[20];
        int writtenSize = range.encode(dst, 0);
        assertEquals(10, writtenSize, "Range size when not large should be 10");
        // create a new empty range and decode
        LockingAndXRange decoded = new LockingAndXRange(false);
        int decodedSize = decoded.decode(dst, 0, dst.length);
        assertEquals(10, decodedSize, "Decode should return size 10");
        assertEquals(99, decoded.getPid());

        NdrShort decoded = new NdrShort(0);
        decoded.decode(buf);
        assertEquals(123, decoded.value, "decoded value should equal original");
    }

    /**
     * Verify that encode invokes NdrBuffer.enc_ndr_short via a mocked
     * (spied) buffer.
     */
    @Test
    void encodeWithSpiedBufferCallsEncMethod() throws NdrException {
        NdrShort ns = new NdrShort(42);

    }

    /**
     * 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

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