}

    private
    fun fetchVersionFromGradleServices(major: Int, targetVersion: String): ReleasedVersion {
        val uri = "https://services.gradle.org/versions/$major"
        val request = HttpRequest.newBuilder().uri(URI(uri)).build()
        val response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString())
        if (response.statusCode() > 399) {

      object : CookieHandler() {
        override fun get(
          uri: URI,
          map: Map<String, List<String>>,
        ) = mapOf(
          "Cookie" to
            listOf(
              "a=\"android \"",
            ),
        )

        override fun put(
          uri: URI,
          map: Map<String, List<String>>,
        ) {
        }
      }
    client =

    }

    /**
     * SAX event handler called when an XML start element is encountered.
     * Processes collection definitions and tracks the element hierarchy.
     *
     * @param uri the namespace URI, or empty string if none
     * @param localName the local name without prefix, or empty string if namespace processing is not performed

        val encodedMilestone = milestone.get().replace(" ", "+")
        val uri = "https://api.github.com/search/issues?q=is:issue+is:closed+repo:gradle/gradle+milestone:$encodedMilestone&per_page=$PAGE_SIZE&page=$pageNumber"
        val requestBuilder = HttpRequest.newBuilder().uri(URI(uri))
        if (githubToken.isPresent) {
            requestBuilder.header("Authorization", "token ${githubToken.get()}")

import jakarta.validation.ConstraintDefinitionException;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

/**
 * Validator implementation for URI type constraints.
 * This validator checks URI strings against specified protocol types.
 */
public class UriTypeValidator implements ConstraintValidator<UriType, String> {

    /**
     * Default constructor for UriTypeValidator.
     */

    val uri = httpUrl.toUri()
    val toAndFromUri = uri.toHttpUrlOrNull()
    val uriStripped = uriStrippedCodePoints.indexOf(codePointString) != -1
    if (uriStripped) {
      if (uri.toString() != component.urlString("")) {
        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

   * These differences may have a significant consequence when the URI is interpreted by a
   * web server. For this reason the [URI class][URI] and this method should be avoided.
   */
  @JvmName("uri")
  fun toUri(): URI {
    val uri = newBuilder().reencodeForUri().toString()
    return try {
      URI(uri)
    } catch (e: URISyntaxException) {
      // Unlikely edge case: the URI has a forbidden character in the fragment. Strip it & retry.

      OkHttpClient
        .Builder()
        .build()
    val proxySelector: ProxySelector =
      object : ProxySelector() {
        override fun select(uri: URI): List<Proxy> = listOf()

        override fun connectFailed(
          uri: URI,
          socketAddress: SocketAddress,
          e: IOException,
        ) {}
      }

    val trustManager = get().platformTrustManager()

      override val nonDefaultValue: ProxySelector =
        object : ProxySelector() {
          override fun select(uri: URI?): MutableList<Proxy> = mutableListOf(java.net.Proxy.NO_PROXY)

          override fun connectFailed(
            uri: URI?,
            sa: SocketAddress?,
            ioe: java.io.IOException?,
          ) {
          }
        }

    assertThat(simplifyPath("./.././../")).isEqualTo("../..");
  }

  /*
   * We co-opt some URI resolution tests for our purposes.
   * Some of the tests have queries and anchors that are a little silly here.
   */

  /** http://gbiv.com/protocols/uri/rfc/rfc2396.html#rfc.section.C.1 */
  public void testRfc2396Normal() {
    assertThat(simplifyPath("/a/b/c/g")).isEqualTo("/a/b/c/g");