url = server.url("/api/login?user=test_user&authentication=basic&password=confidential_password")
    val networkInterceptor =
      HttpLoggingInterceptor(networkLogs).setLevel(
        Level.BASIC,
      )
    networkInterceptor.redactQueryParams("user", "passWord")

    val applicationInterceptor =
      HttpLoggingInterceptor(applicationLogs).setLevel(
        Level.BASIC,
      )

Logging Interceptor
===================

An [OkHttp interceptor][interceptors] which logs HTTP request and response data.

```java
HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(Level.BASIC);
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(logging)
  .build();
```

You can change the log level at any time by calling `setLevel()`.

        code = 407,
        headers = headersOf("Proxy-Authenticate", "Basic realm=\"localhost\""),
      ),
    )
    server.enqueue(
      MockResponse(body = "response body"),
    )
    client =
      client.newBuilder()
        .proxy(server.toProxyAddress())
        .proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))
        .build()

      Response.Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)
        .message("Unauthorized")
        .build()
    val authRequest = authenticator.authenticate(route, response)

    assertEquals(
      "Basic ${RecordingAuthenticator.BASE_64_CREDENTIALS}",
      authRequest!!.header("Authorization"),
    )
  }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.tls.internal.der

import java.net.ProtocolException

/**
 * Handles basic types that always use the same tag. This supports optional types and may set a type
 * hint for further adapters to process.
 *
 * Types like ANY and CHOICE that don't have a consistent tag cannot use this.
 */

    val request = response.request
    val url = request.url
    val proxyAuthorization = response.code == 407
    val proxy = route?.proxy ?: Proxy.NO_PROXY

    for (challenge in challenges) {
      if (!"Basic".equals(challenge.scheme, ignoreCase = true)) {
        continue
      }

      val dns = route?.address?.dns ?: defaultDns
      val auth =
        if (proxyAuthorization) {

import okhttp3.tls.internal.der.CertificateAdapters.generalNameIpAddress
import okhttp3.tls.internal.der.Extension
import okhttp3.tls.internal.der.ObjectIdentifiers
import okhttp3.tls.internal.der.ObjectIdentifiers.BASIC_CONSTRAINTS
import okhttp3.tls.internal.der.ObjectIdentifiers.ORGANIZATIONAL_UNIT_NAME
import okhttp3.tls.internal.der.ObjectIdentifiers.SHA256_WITH_ECDSA
import okhttp3.tls.internal.der.ObjectIdentifiers.SHA256_WITH_RSA_ENCRYPTION

  @Test
  fun testHttpLoggingInterceptor() {
    val interceptor =
      HttpLoggingInterceptor.androidLogging(tag = "testHttpLoggingInterceptor").apply {
        level = HttpLoggingInterceptor.Level.BASIC
      }

    val client = clientBuilder.addInterceptor(interceptor).build()

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

    // Indexed name (idx = 60) -> "www-authenticate"
    bytesIn.writeByte(0x05) // Literal value (len = 5)
    bytesIn.writeUtf8("Basic")
    hpackReader!!.readHeaders()
    assertThat(hpackReader!!.getAndResetHeaderList())
      .containsExactly(Header("www-authenticate", "Basic"))
  }

  @Test
  fun readLiteralHeaderWithIncrementalIndexingDynamicName() {
    bytesIn.writeByte(0x40)

\#\u03B2  s:http h:example.org p:/foo/bar f:#\u03B2
data:text/html,test#test  s:data p:text/html,test f:#test

# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html

# Basic canonicalization, uppercase should be converted to lowercase
file:c:\\foo\\bar.html file:///tmp/mock/path s:file p:/c:/foo/bar.html

# Spaces should fail
\s\sFile:c|////foo\\bar.html  s:file p:/c:////foo/bar.html