*/
  public static BaseEncoding base64() {
    return BASE64;
  }

  private static final BaseEncoding BASE64_URL =
      new Base64Encoding(
          "base64Url()", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", '=');

  /**
   * The "base64url" encoding specified by <a
   * href="http://tools.ietf.org/html/rfc4648#section-5">RFC 4648 section 5</a>, Base 64 Encoding

		readDirFn(pathJoin(drivePath, minioMetaMultipartBucket, shaDir), func(uploadIDDir string, typ os.FileMode) error {
			uploadIDPath := pathJoin(shaDir, uploadIDDir)
			var modTime time.Time
			// Upload IDs are of the form base64_url(<UUID>x<UnixNano>), we can extract the time from the UUID.
			if b64, err := base64.RawURLEncoding.DecodeString(uploadIDDir); err == nil {
				if split := strings.Split(string(b64), "x"); len(split) == 2 {

  }

  public void testBase64Url() {
    testDecodesByBytes(base64Url(), "_zzz", new byte[] {-1, 60, -13});
    testDecodesByBytes(base64Url(), "-zzz", new byte[] {-5, 60, -13});
  }

  public void testBase64UrlInvalidDecodings() {
    assertFailsToDecode(base64Url(), "+zzz", "Unrecognized character: +");
    assertFailsToDecode(base64Url(), "/zzz", "Unrecognized character: /");
  }

  public void testBase32() {

  }

  public void testBase64Url() {
    testDecodesByBytes(base64Url(), "_zzz", new byte[] {-1, 60, -13});
    testDecodesByBytes(base64Url(), "-zzz", new byte[] {-5, 60, -13});
  }

  public void testBase64UrlInvalidDecodings() {
    assertFailsToDecode(base64Url(), "+zzz", "Unrecognized character: +");
    assertFailsToDecode(base64Url(), "/zzz", "Unrecognized character: /");
  }

  public void testBase32() {

    assertThat(encoded).isEqualTo("AAABAAABAAAAAAAABmdvb2dsZQNjb20AAAEAAQ")
  }

  private fun encodeQuery(
    host: String,
    type: Int,
  ): String {
    return DnsRecordCodec.encodeQuery(host, type).base64Url().replace("=", "")
  }

  @Test
  fun testGoogleDotComEncodingWithIPv6() {
    val encoded = encodeQuery("google.com", TYPE_AAAA)
    assertThat(encoded).isEqualTo("AAABAAABAAAAAAAABmdvb2dsZQNjb20AABwAAQ")
  }

import pytest
from httpx import ASGITransport, AsyncClient

from .main import app


@pytest.mark.anyio
async def test_root():
    async with AsyncClient(
        transport=ASGITransport(app=app), base_url="http://test"
    ) as ac:
        response = await ac.get("/")
    assert response.status_code == 200

 */
package okhttp3.survey.ssllabs

import retrofit2.http.GET

interface SslLabsApi {
  @GET("getClients")
  suspend fun clients(): List<UserAgentCapabilities>

  companion object {
    const val BASE_URL = "https://api.ssllabs.com/api/v3/"
  }

///

::: fastapi.WebSocket
    options:
        members:
            - scope
            - app
            - url
            - base_url
            - headers
            - query_params
            - path_params
            - cookies
            - client
            - state
            - url_for
            - client_state

) {
  private val moshi = Moshi.Builder().build()

  private val moshiConverterFactory = MoshiConverterFactory.create(moshi)

  private val retrofit =
    Retrofit.Builder()
      .baseUrl(SslLabsApi.BASE_URL)
      .addConverterFactory(moshiConverterFactory)
      .callFactory(callFactory)
      .build()

  private val sslLabsApi = retrofit.create(SslLabsApi::class.java)

  suspend fun clients(): List<Client> {

            url.newBuilder()
              .addQueryParameter("hostname", hostname).build(),
          )
          .post(query.toRequestBody(DNS_MESSAGE))
      } else {
        val encoded = query.base64Url().replace("=", "")
        val requestUrl = url.newBuilder().addQueryParameter("dns", encoded).build()

        url(requestUrl)
      }
    }.build()

  class Builder {