//                                                                          ==========
    protected static final int HTTP_BAD_REQUEST = 400;
    protected static final int HTTP_UNAUTHORIZED = 401;

    // ===================================================================================
    //                                                                    Business Failure

        }
    }

    private void doHandshake() throws IOException {
        connect();
        try {
            int response = parseResponseCode();
            if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {
                return;
            }
            final Type1Message type1 = (Type1Message) attemptNegotiation(response);
            if (type1 == null) {

        // Arrange
        mockResponse(HTTP_UNAUTHORIZED, "Unauthorized",
                Collections.singletonMap("WWW-Authenticate", Collections.singletonList("Basic realm=\"Test\"")),
                new ByteArrayInputStream(new byte[0]));

        // Act
        int responseCode = ntlmConnection.getResponseCode();

        // Assert
        assertEquals(HTTP_UNAUTHORIZED, responseCode);

import java.net.HttpURLConnection.HTTP_MULT_CHOICE
import java.net.HttpURLConnection.HTTP_PROXY_AUTH
import java.net.HttpURLConnection.HTTP_SEE_OTHER
import java.net.HttpURLConnection.HTTP_UNAUTHORIZED
import okhttp3.ResponseBody.Companion.asResponseBody
import okhttp3.internal.connection.Exchange
import okhttp3.internal.http.HTTP_PERM_REDIRECT
import okhttp3.internal.http.HTTP_TEMP_REDIRECT

        }
    }

    private void doHandshake() throws IOException, GeneralSecurityException {
        connect();
        try {
            int response = parseResponseCode();
            if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {
                return;
            }
            final NtlmMessage type1 = attemptNegotiation(response);
            if (type1 == null) {
                return; // no NTLM

        .requestIOException()
        .exhaustResponse()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .code(HttpURLConnection.HTTP_UNAUTHORIZED)
        .socketHandler(body1)
        .build(),
    )
    val body =
      MockSocketHandler()
        .sendResponse("response body\n")
        .exhaustResponse()

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun authenticate(protocol: Protocol) {
    setUp(protocol)
    server.enqueue(
      MockResponse(
        code = HttpURLConnection.HTTP_UNAUTHORIZED,
        headers = headersOf("www-authenticate", "Basic realm=\"protected area\""),
        body = "Please authenticate.",
      ),
    )
    server.enqueue(
      MockResponse(body = "Successful auth!"),

   * new HTTP request to be issued for every call into the URLConnection.
   */
  @Test
  fun unauthorizedResponseHandling() {
    val mockResponse =
      MockResponse(
        code = HttpURLConnection.HTTP_UNAUTHORIZED,
        headers = headersOf("WWW-Authenticate", "challenge"),
        body = "Unauthorized",
      )
    server.enqueue(mockResponse)
    server.enqueue(mockResponse)
    server.enqueue(mockResponse)

    when (responseCode) {
      HttpURLConnection.HTTP_PROXY_AUTH -> {
        builder.addHeader("Proxy-Authenticate: Basic realm=\"protected area\"")
      }

      HttpURLConnection.HTTP_UNAUTHORIZED -> {
        builder.addHeader("WWW-Authenticate: Basic realm=\"protected area\"")
      }

      HttpURLConnection.HTTP_NO_CONTENT, HttpURLConnection.HTTP_RESET -> {