*
   * It is an error to call this method after the body has been consumed.
   *
   * **Warning:** this method loads the requested bytes into memory. Most applications should set
   * a modest limit on `byteCount`, such as 1 MiB.
   */
  @Throws(IOException::class)
  fun peekBody(byteCount: Long): ResponseBody {
    val peeked = body.source().peek()
    val buffer = Buffer()
    peeked.request(byteCount)

    } 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>()

			 "node.name":"search_engine",
			 "discovery.seed_hosts":"search_engine",
			 "cluster.initial_cluster_manager_nodes":"search_engine",
			 "node.roles":"cluster_manager,data,ingest,ml",
			 -->
			 "indices.breaker.total.limit":"100%",
			 "action.auto_create_index":"-*"}
		</property>
		<!-- Dictionaries -->
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"mapping.txt"</arg>
		</postConstruct>

 * the life cycle methods.
 *
 * <h3>Usage Example</h3>
 *
 * <p>Here is a sketch of a service which crawls a website and uses the scheduling capabilities to
 * rate limit itself.
 *
 * {@snippet :
 * class CrawlingService extends AbstractScheduledService {
 *   private Set<Uri> visited;
 *   private Queue<Uri> toCrawl;
 *   protected void startUp() throws Exception {

    String SUGGEST_UPDATE_CONTENTS_LIMIT_NUM_PERCENTAGE = "suggest.update.contents.limit.num.percentage";

    /** The key of the configuration. e.g. 10000 */
    String SUGGEST_UPDATE_CONTENTS_LIMIT_NUM = "suggest.update.contents.limit.num";

    /** The key of the configuration. e.g. 50000 */
    String SUGGEST_UPDATE_CONTENTS_LIMIT_DOC_SIZE = "suggest.update.contents.limit.doc.size";

    /** The key of the configuration. e.g. 1 */

 *  Fix: MockWebServer explicitly closes sockets. (On some Android releases,
    closing the input stream and output stream of a socket is not sufficient.
 *  Fix: Buffer outgoing HTTP/2 frames to limit how many outgoing frames are
    created.
 *  Fix: Avoid crashing when cache writing fails due to a full disk.
 *  Fix: Improve caching of private responses.
 *  Fix: Update cache-by-default response codes.

        ComponentUtil.setFessConfig(new MockFessConfig() {
            @Override
            public Integer getCookieSearchParameterMaxLengthAsInteger() {
                return 10; // Very small limit
            }
        });

        String longValue = "a".repeat(1000);
        getMockRequest().setParameter("q", longValue);

        searchHelper.storeSearchParameters();

                    logger.debug("Interrupted.", e);
                }
            }
        }

        /**
         * Waits for the crawling thread to terminate within a specified time limit.
         * This method blocks until the thread completes or the timeout expires.
         *
         * @param mills maximum time to wait in milliseconds
         */

        }).orElse(StringUtil.EMPTY_STRINGS);
    }

    /**
     * Retrieves or creates the result document IDs cache from the session.
     * The cache is implemented as an LRU map to limit memory usage.
     *
     * @param session the HTTP session
     * @return the result document IDs cache map
     */
    private Map<String, String[]> getResultDocIdsCache(final HttpSession session) {

  }

  /**
   * Specifies the maximum number of entries the cache may contain.
   *
   * <p>Note that the cache <b>may evict an entry before this limit is exceeded</b>. For example, in
   * the current implementation, when {@code concurrencyLevel} is greater than {@code 1}, each
   * resulting segment inside the cache <i>independently</i> limits its own size to approximately