call: RealCall,
      e: IOException?,
    )

    fun noNewExchanges()

    fun cancel()
  }

  companion object {
    /**
     * The timeout to use while discarding a stream of input data. Since this is used for connection
     * reuse, this timeout should be significantly less than the time it takes to establish a new
     * connection.
     */
    const val DISCARD_STREAM_TIMEOUT_MILLIS = 100
  }

import okio.buffer

/**
 * Caches HTTP and HTTPS responses to the filesystem so they may be reused, saving time and
 * bandwidth.
 *
 * The Cache instance must have exclusive access to the [directory], since the internal data structures
 * may cause corruption or runtime errors if not. It may however be shared amongst multiple OkHttpClient
 * instances.
 *
 * ## Cache Optimization
 *

        return postcard;
    }

    // ===================================================================================
    //                                                                           Meta Data
    //                                                                           =========
    @Override
    protected String getBodyFile() {
        return PATH;
    }

    @Override

        writeTestFile("");

        OptionalEntity<CharMappingItem> result = charMappingFile.get(1L);
        assertFalse(result.isPresent());
    }

    // Test get method with valid data
    @Test
    public void test_get_validData() throws Exception {
        writeTestFile("a,b => c\nd,e => f\n");

        OptionalEntity<CharMappingItem> result1 = charMappingFile.get(1L);

   *     this response.
   */
  open fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
  }

  /**
   * Invoked when data from the response body is first available to the application.
   *
   * This is typically invoked immediately before bytes are returned to the application. If the

                capturedParams.set(initParamMap);
            }

            @Override
            public void stop() {
                // Do nothing
            }
        };

        // Create test data
        DataConfig config = new DataConfig();
        config.setName("test-config");

        DataStoreParams params = new DataStoreParams();
        params.put("key1", "value1");
        params.put("key2", "value2");

    @Test
    public void test_render_xss_dataProtocol() {
        String malicious = "[Click me](data:text/html,<script>alert('XSS')</script>)";
        String result = markdownRenderer.render(malicious);
        // data: protocol should be blocked
        assertFalse(result.contains("data:text/html"));
    }

    @Test
    public void test_render_xss_imgOnerror() {

   * designed for this nonstandard interaction will use it. As of 2019-01, the only widely-used
   * implementation of this pattern is [gRPC][grpc].
   *
   * Because the encoding of interleaved data is not well-defined for HTTP/1, duplex request
   * bodies may only be used with HTTP/2. Calls to HTTP/1 servers will fail before the HTTP request

 * contains information about the named HTML entities such as {@code &} and {@code "} while
 * {@link #escapeUnsafe} is overridden to handle general escaping of the form {@code &#NNNNN;}.
 *
 * <p>The size of the data structure used by {@link ArrayBasedUnicodeEscaper} is proportional to the
 * highest valued code point that requires escaping. For example a replacement map containing the

   * the cache is not recording statistics. All statistics begin at zero and never decrease over the
   * lifetime of the cache.
   *
   * <p><b>Warning:</b> this cache may not be recording statistical data. For example, a cache
   * created using {@link CacheBuilder} only does so if the {@link CacheBuilder#recordStats} method
   * was called. If statistics are not being recorded, a {@code CacheStats} instance with zero for