}

    /**
     * Deletes a document by ID from the search index.
     *
     * @param id the document ID to delete
     * @return JSON response indicating success or failure
     */
    // DELETE /api/admin/searchlist/doc/{doc_id}
    @Execute
    public JsonResponse<ApiResult> delete$doc(final String id) {
        try {

        assertEquals('S', messageBytes[5]);
        assertEquals('P', messageBytes[6]);
        assertEquals(0, messageBytes[7]); // Null terminator
    }

    @Test
    @DisplayName("Should include message type indicator")
    void testMessageTypeIndicator() throws Exception {
        // Given
        Type2Message type2 = createMockType2Message();

                // Configure mock to do nothing when called
                mockedSMBUtil.when(() -> SMBUtil.writeInt2(anyLong(), any(byte[].class), anyInt())).thenAnswer(invocation -> null);

                byte[] dst = new byte[buffer.size()];
                buffer.encode(dst, 0);

                // Verify SMBUtil.writeInt2 was called for referral level (with long parameter)

   *     unwrapping conversion for primitive arguments fails; or if, after possible unwrapping, a
   *     parameter value cannot be converted to the corresponding formal parameter type by a method
   *     invocation conversion.
   * @throws InvocationTargetException if the underlying method or constructor throws an exception.
   */
  // All subclasses are owned by us and we'll make sure to get the R type right, including nullness.

         * the andx command will not be written and therefore the
         * response will not read a batched command and therefore
         * the 'received' member of the response object will not
         * be set to true indicating the send and sendTransaction
         * methods that the next part should be sent. This is a
         * very indirect and simple batching control mechanism.
         */

    @Resource
    protected SystemHelper systemHelper;

    /** Helper for document indexing operations */
    @Resource
    protected IndexingHelper indexingHelper;

    /** Flag indicating if crawling should be finished */
    protected boolean finishCrawling = false;

    /** Total execution time in milliseconds */
    protected long executeTime;

    /** Total number of processed documents */

            } else if (e instanceof java.lang.reflect.InvocationTargetException) {
                // Method exists but failed to execute, which is acceptable in test environment
                assertTrue("Method invocation failed in test environment", true);
            } else {
                fail("Failed to test getExpiredTime method: " + (message != null ? message : e.getClass().getSimpleName()));
            }
        }
    }

   * throwing exceptions like {@link NoSuchElementException} at the appropriate times, it throws
   * {@link PermittedMetaException} instances, which wrap a set of all exceptions that the iterator
   * could throw during the invocation of that method. This is necessary because, e.g., a call to
   * {@code iterator().remove()} of an unmodifiable list could throw either {@link
   * IllegalStateException} or {@link UnsupportedOperationException}. Note that iterator

        /** The process to monitor and destroy. */
        private final Process p;

        /** The input stream thread reading process output. */
        private final InputStreamThread ist;

        /** Flag indicating if the destroyer has been executed. */
        private final AtomicBoolean executed = new AtomicBoolean(false);

        /** Timeout for process destruction in milliseconds. */
        private final long timeout;

        </field>
        <field>
          <name>prefix</name>
          <type>String</type>
          <required>true</required>
          <version>1.0.0+</version>
          <description>The plugin invocation prefix (i.e. eclipse for eclipse:eclipse)</description>
        </field>
        <field>
          <name>artifactId</name>
          <type>String</type>
          <required>true</required>