when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '''<para>&lt;&gt;&amp; /&gt;</para>'''
    }

    def ignoresHtmlComments() {
        _ * classMetaData.rawCommentText >> '<!-- <p>ignore me</p> --><p>para 1'

        when:
        def result = parser.parse(classMetaData, listener)

        then:

    @DisplayName("Test writeBytesWireFormat returns 0")
    void testWriteBytesWireFormat() {
        byte[] dst = new byte[1024];
        int dstIndex = 0;

        int result = response.writeBytesWireFormat(dst, dstIndex);

        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test readBytesWireFormat with valid structure size")
    void testReadBytesWireFormatValidStructureSize() throws SMBProtocolDecodingException {

                            versions.add(ver);
                            result.setRepository(ver, v.getValue());
                        }
                    } catch (InvalidVersionSpecificationException e) {
                        result.addException(e);
                    }
                }

                Collections.sort(versions);
                result.setVersions(versions);
            }
        }

                return mockResource1;
            }
        };

        // When
        SmbResource result = iterator.next();

        // Then
        assertTrue(adaptCalled[0], "Adapt method should have been called");
        assertNotNull(result, "Result should not be null");
        assertEquals("file1.txt", result.getName());
    }

    val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
    factory.init(trustStore)
    val result = factory.trustManagers!!
    check(result.size == 1 && result[0] is X509TrustManager) {
      "Unexpected trust managers: ${result.contentToString()}"
    }

    val trustManager = result[0] as X509TrustManager

    return when {
      insecureHosts.isEmpty() -> trustManager

    }

    public void test_stripInvalidXMLCharacters_valid() {
        // Test valid XML characters
        String input = "Valid XML text 123\t\n\r";
        String result = XmlUtil.stripInvalidXMLCharacters(input);
        assertNotNull(result);
        assertTrue(result.contains("Valid XML text 123"));
    }

    public void test_stripInvalidXMLCharacters_withInvalidChars() {

            return asJson(
                    new ApiResult.ApiErrorResponse().message("invalid name or version").status(ApiResult.Status.BAD_REQUEST).result());
        }
        installArtifact(artifact);
        return asJson(new ApiResult.ApiResponse().status(ApiResult.Status.OK).result());
    }

    /**
     * Deletes a plugin with the specified name and version.
     *

        // Given
        when(request.initResponse(context)).thenReturn(response);

        // When
        CommonServerMessageBlockResponse result = request.initResponse(context);

        // Then
        assertNotNull(result);
        assertEquals(response, result);
        verify(request, times(1)).initResponse(context);
    }

    @Test
    @DisplayName("Test initResponse with null context")

            return result -> {
                result.logger = shellContext.logger;
                result.loggerFactory = shellContext.loggerFactory;
                result.slf4jConfiguration = shellContext.slf4jConfiguration;
                result.loggerLevel = shellContext.loggerLevel;
                result.coloredOutput = shellContext.coloredOutput;
                result.terminal = shellContext.terminal;

    }

    @Override
    protected <RESULT extends CrawlingInfoParam> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setCrawlingInfoId(DfTypeUtil.toString(source.get("crawlingInfoId")));
            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));