// No authorization header for the first request...
    var request = server.takeRequest()
    assertThat(request.headers["Authorization"]).isNull()

    // ...but the three requests that follow requests include an authorization header.
    for (i in 0..2) {
      request = server.takeRequest()
      assertThat(request.requestLine).isEqualTo("GET / HTTP/1.1")
      assertThat(request.headers["Authorization"])

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Cancel request message.
 *
 * This command is used to cancel a previously sent command
 * that is still being processed by the server.
 *
 * @author mbechler
 */
public class Smb2CancelRequest extends ServerMessageBlock2 implements CommonServerMessageBlockRequest {

    /**
     * Constructs a SMB2 cancel request
     *
     * @param config

        commandField.setAccessible(true);
        int command = (int) commandField.get(request);
        assertEquals(0x0007, command); // SMB2_FLUSH value

        // Verify file ID is set
        Field fileIdField = Smb2FlushRequest.class.getDeclaredField("fileId");
        fileIdField.setAccessible(true);
        byte[] storedFileId = (byte[]) fileIdField.get(request);
        assertArrayEquals(testFileId, storedFileId);
    }

    @Test

            message.setShareName(request.getShareName());
            message.setIpAddress(request.getServerAddress());
            message.setClientComputerName(context.getConfig().getNetbiosHostname());
            message.setFlags(request.getFlags());
            message.setTimeout((int) (context.getConfig().getWitnessRegistrationTimeout() / 1000));

            // Send the RPC request
            rpcHandle.sendrecv(message);

		t.Fatalf("MinIO %s: Failed to create an anonymous request for bucket \"%s\": <ERROR> %v",
			instanceType, bucketName, err)
	}

	// ExecObjectLayerAPIAnonTest - Calls the HTTP API handler using the anonymous request, validates the ErrAccessDeniedResponse,
	// sets the bucket policy using the policy statement generated from `getWriteOnlyObjectStatement` so that the
	// unsigned request goes through and its validated again.

    /**
     * Creates a key for the specified request for response matching.
     *
     * @param request the request to create a key for
     * @throws IOException if an I/O error occurs
     */
    protected abstract void makeKey(Request request) throws IOException;

    /**
     * Reads and returns the key of the next message without consuming it.
     *
     * @return the request key of the next message

      }
    val client =
      clientTestRule
        .newClientBuilder()
        .proxySelector(proxySelector)
        .build()
    val request = Request.Builder().url(server.url("/")).build()
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("abc")
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun checkRemoteDNSResolve() {

import okio.buffer

/** Rewrites the request body sent to the server to be all uppercase.  */
class UppercaseRequestInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Chain): Response = chain.proceed(uppercaseRequest(chain.request()))

  /** Returns a request that transforms `request` to be all uppercase.  */
  private fun uppercaseRequest(request: Request): Request {
    val uppercaseBody: RequestBody =

/**
 * Interface for managing web API request processing.
 * Implementations of this interface handle specific types of web API requests
 * by matching incoming requests and processing them accordingly.
 */
public interface WebApiManager {

    /**
     * Checks if the request matches this API manager.
     * @param request The HTTP servlet request.
     * @return True if the request matches, false otherwise.
     */

    public ArtifactResolutionResult resolve(ArtifactResolutionRequest request) {
        Artifact rootArtifact = request.getArtifact();
        Set<Artifact> artifacts = request.getArtifactDependencies();
        Map<String, Artifact> managedVersions = request.getManagedVersionMap();
        List<ResolutionListener> listeners = request.getListeners();
        ArtifactFilter collectionFilter = request.getCollectionFilter();