/**
     * Returns a new request body that transmits this string. If [contentType] is non-null and lacks
     * a charset, this will use UTF-8.
     */
    @JvmStatic
    @JvmName("create")
    fun String.toRequestBody(contentType: MediaType? = null): RequestBody {
      val (charset, finalContentType) = contentType.chooseCharset()
      val bytes = toByteArray(charset)

        assertFalse(exception.aborted());
    }

    public void test_constructor_withAllNullParameters() {
        // Test with all null parameters except abort
        String url = null;
        String message = null;
        Exception cause = null;
        boolean abort = true;

        DataStoreCrawlingException exception = new DataStoreCrawlingException(url, message, cause, abort);

      val sslContextClass = Class.forName("sun.security.ssl.SSLContextImpl")
      val context = readFieldOrNull(sslSocketFactory, sslContextClass, "context") ?: return null
      readFieldOrNull(context, X509TrustManager::class.java, "trustManager")
    } catch (e: ClassNotFoundException) {
      null
    } catch (e: RuntimeException) {
      // Throws InaccessibleObjectException (added in JDK9) on JDK 17 due to

   * the call to {@code contains(null)} is permitted to throw a {@code NullPointerException}.
   *
   * @param message message to use upon assertion failure
   */
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {
      assertFalse(message, getMap().containsKey(null));
    } catch (NullPointerException tolerated) {

      @JvmStatic
      fun create(body: RequestBody): Part = create(null, body)

      @JvmStatic
      fun create(
        headers: Headers?,
        body: RequestBody,
      ): Part {
        require(headers?.get("Content-Type") == null) { "Unexpected header: Content-Type" }
        require(headers?.get("Content-Length") == null) { "Unexpected header: Content-Length" }
        return Part(headers, body)
      }

        assertNotNull(readings);
        assertTrue(readings.isEmpty());
    }

    @Test
    public void testConvertWithNullText() throws IOException {
        // Test convert with null text
        converter.init();
        String text = null;
        String field = "content";

        List<String> readings = converter.convert(text, field, "en");

        assertNotNull(readings);
        assertTrue(readings.isEmpty());

/**
 * @param {?string} str
 * @return {boolean} Whether the given string is null or is the empty string.
 * @public
 */
Platform.stringIsNullOrEmpty = function(str) {
  return !str;
};


/**
 * @param {?string} str
 * @return {string} Original str, if it is non-null. Otherwise empty string.
 */
Platform.nullToEmpty = function(str) {
  return str || "";
};


/**
 * @param {?string} str

        assertEquals("http://test.com/sitemap.xml", removedSitemaps[1]);

        // Should be null after removal
        assertNull(crawlerContext.removeSitemaps());

        // Test with null
        crawlerContext.addSitemaps(null);
        assertNull(crawlerContext.removeSitemaps());

        // Test with empty array
        crawlerContext.addSitemaps(new String[0]);

            }

            Arrays.sort(array, (o1, o2) -> {
                if (o1 == null && o2 == null) {
                    return 0;
                }
                if (o1 == null) {
                    return -1;
                }
                if (o2 == null) {
                    return 1;
                }

                final Object timeObj1 = o1.get(FieldNames.TIMESTAMP);

        assertNotSame(component, component2);
    }

    /**
     * Test creation with null component name
     */
    public void test_create_nullComponentName() {
        factory.setComponentName(null);

        try {
            factory.create();
            fail("Should throw exception for null component name");
        } catch (Exception e) {
            // Expected behavior