this.data = data;
    }

    /**
     * Add a child URL.
     * @param url the request data to add to the child URL set
     */
    public void addUrl(final RequestData url) {
        childUrlSet.add(url);
    }

    /**
     * Add child URLs.
     * @param c the collection of request data to add to the child URL set
     */
    public void addAllUrl(final Collection<RequestData> c) {

    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true
    // Large headers are a likely reason the servers would cut off the connection before it completes sending
    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody

class PostFile {
  private val client = OkHttpClient()

  fun run() {
    val file = File("README.md")

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = file.asRequestBody(MEDIA_TYPE_MARKDOWN),

import jcifs.internal.util.SMBUtil;

/**
 * SMB1 Find Close2 request message.
 *
 * This command is used to close a search handle that was
 * opened by a Trans2 Find First2 request.
 */
public class SmbComFindClose2 extends ServerMessageBlock {

    private final int sid;

    /**
     * Creates a new SMB1 find close request to close a search handle.
     *
     * @param config the CIFS configuration

        ArtifactResolverRequest request3 = builder.session(session)
                .coordinates(Arrays.asList(coords2, coords1)) // Different order
                .repositories(repositories1)
                .build();

        // Test equals and hashCode
        assertEquals(request1, request2);
        assertEquals(request1.hashCode(), request2.hashCode());
        assertNotEquals(request1, request3);

        // Test toString

 * This enum is used to differentiate between various SSO operations,
 * such as metadata requests and logout actions.
 */
public enum SsoResponseType {
    /**
     * Indicates a request for SSO metadata, which is typically used for
     * configuration and discovery in protocols like SAML.
     */
    METADATA,

    /**
     * Indicates a request to perform a logout operation, terminating the
     * user's SSO session.
     */

     * Creates artifact coordinates.
     *
     * @param request the request holding coordinates creation parameters
     * @return an {@code ArtifactCoordinates}, never {@code null}
     * @throws IllegalArgumentException if {@code request} is null or {@code request.session} is null or invalid
     */
    @Nonnull
    ArtifactCoordinates create(@Nonnull ArtifactCoordinatesFactoryRequest request);

    /**

    if (algorithms.isNotEmpty() && chain.request().header("Accept-Encoding") == null) {
      val request =
        chain
          .request()
          .newBuilder()
          .header("Accept-Encoding", acceptEncoding)
          .build()

      val response = chain.proceed(request)

      decompress(response)
    } else {
      chain.proceed(chain.request())
    }

  /**

 */
package org.codelibs.fess.app.web.api.admin.reqheader;

import org.codelibs.fess.app.web.admin.reqheader.EditForm;

/**
 * Request body class for request header edit operations in the admin REST API.
 * This class extends EditForm to inherit the necessary form validation and binding capabilities
 * for request header management operations.
 */
public class EditBody extends EditForm {

    /**
     * Default constructor.
     */

        .build()

    server.enqueue(MockResponse(body = "abc1"))
    server.enqueue(MockResponse(body = "abc2"))

    val request = Request(server.url("/"))

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())