// Multiple writes that exceed threshold should switch to file
        ContentOutputStream cos = new ContentOutputStream(5, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2 });
        assertTrue(cos.isInMemory());
        cos.write(new byte[] { 3, 4, 5 }); // Total 6 bytes, exceeds threshold of 5
        assertFalse(cos.isInMemory());
        File file = cos.getFile();

import java.util.logging.Logger;

import org.apache.commons.io.output.DeferredFileOutputStream;

/**
 * ContentOutputStream is a custom output stream that extends DeferredFileOutputStream.
 * It writes data to a temporary file once the data size exceeds a specified threshold.
 *
 * <p>This class ensures that the temporary file is deleted if it is not needed.

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

/**
 * Filter for CPU load-based request control.
 * Returns HTTP 429 (Too Many Requests) when CPU usage exceeds configurable thresholds.
 * Web and API requests have independent threshold settings.
 */
public class LoadControlFilter implements Filter {

        .build(),
    )
    val call = client.newCall(Request(url = server.url("/")))
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  /** Use a header that exceeds the limits on its own. */
  @Test
  fun largeResponseHeader() {
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Set-Cookie", "a=${"A".repeat(256 * 1024)}")

    }
  }

  private fun loggerTag(loggerName: String): String {
    // We need to handle long logger names before they hit Log.
    // java.lang.IllegalArgumentException: Log tag "okhttp3.mockwebserver.MockWebServer" exceeds limit of 23 characters
    return knownLoggers[loggerName] ?: loggerName.take(23)
  }

  fun enable() {
    try {
      for ((logger, tag) in knownLoggers) {
        enableLogging(logger, tag)
      }

            timeoutTask.cancel();
        }
        if (logNotificationTarget != null) {
            logNotificationTarget.flush();
        }
    }

    /**
     * Offers an event to the buffer. If the buffer exceeds the maximum size, the oldest event is dropped.
     *
     * @param event the log notification event to add
     */
    public void offer(final LogNotificationEvent event) {
        int maxBufferSize;
        try {

     * <p>
     * <strong>Note:</strong> This method loads the entire file into memory.
     * An {@link IORuntimeException} will be thrown if the file exceeds the specified maxSize
     * to prevent OutOfMemoryError. For large files, use streaming APIs instead.
     * </p>
     *
     * @param file
     *            The file. Must not be {@literal null}.

    } catch (ioe: IOException) {
      assertThat(ioe.message).isEqualTo("google.com")
      val cause = ioe.cause!!
      assertThat(cause).isInstanceOf<IOException>()
      assertThat(cause).hasMessage("response size exceeds limit (65536 bytes): 65537 bytes")
    }
  }

  @Test
  fun failOnBadResponse() {
    server.enqueue(dnsResponse("00"))
    try {
      dns.lookup("google.com")
      fail<Any>()

            final int maxMessageLength = getMaxMessageLength(fessConfig);
            if (message.length() > maxMessageLength) {
                logger.warn("Chat message exceeds max length. length={}, max={}", message.length(), maxMessageLength);
                writeJsonResponse(response, HttpServletResponse.SC_BAD_REQUEST,

                        } else {
                            responseData.setResponseBody(file, false);
                            if (logger.isDebugEnabled()) {
                                logger.debug("File size exceeds cache threshold, using file reference: file={}, size={}, threshold={}",
                                        file.getAbsolutePath(), file.length(), maxCachedContentSize);
                            }
                        }