rule.server
              .url("/")
              .toUrl()
              .openConnection()
              .connect()
          }
        },
        Description.EMPTY,
      )
    statement.evaluate()
    assertThat(called.get()).isTrue()
    try {
      rule.server
        .url("/")
        .toUrl()
        .openConnection()
        .connect()
      fail()

        final URL url = new File("/Program File").toURI().toURL();
        assertEquals("file:" + getRoot() + "Program File", ResourceUtil.toExternalForm(url));
    }

    /**
     * @throws Exception
     */
    public void testGetFileName() throws Exception {
        URL url = new File("/Program File").toURI().toURL();
        assertEquals(getRoot() + "Program File", ResourceUtil.getFileName(url));

    /**
     * @throws Exception
     */
    public void testToJarFilePath() throws Exception {
        final File f = new File("/Program Files/foo.jar");
        final URL url = new URL("jar:" + f.toURI().toURL() + "!/");
        final String root = new File("/").getCanonicalPath();
        assertEquals(root + "Program Files" + File.separator + "foo.jar", JarFileUtil.toJarFilePath(url));
    }

    /**
     * @throws Exception

            challenge.scheme,
            url.toUrl(),
            Authenticator.RequestorType.PROXY,
          )
        } else {
          Authenticator.requestPasswordAuthentication(
            url.host,
            proxy.connectToInetAddress(url, dns),
            url.port,
            url.scheme,
            challenge.realm,
            challenge.scheme,
            url.toUrl(),
            Authenticator.RequestorType.SERVER,

          requestsMade.add(request)
          return MockResponse()
        }
      }
    assertThat(requestsMade.size).isEqualTo(0)
    mockWebServer.dispatcher = dispatcher
    val url = mockWebServer.url("/").toUrl()
    val conn = url.openConnection() as HttpURLConnection
    conn.responseCode // Force the connection to hit the "server".
    // Make sure our dispatcher got the request.
    assertThat(requestsMade.size).isEqualTo(1)
  }

      assertThat(response.protocol).isEqualTo(Protocol.HTTP_1_1)
    }
  }

  @Test
  fun testUrlConnectionDirect() {
    testRequest {
      val url = URI(mockServer.endpoint + "/person?name=peter").toURL()

      val connection = url.openConnection() as HttpURLConnection

      assertThat(
        connection.inputStream
          .source()
          .buffer()
          .readUtf8(),

        final URL classURL = ResourceUtil.getResource(classFilePath);
        final URL jarURL = new File(JarFileUtil.toJarFilePath(classURL)).toURI().toURL();
        ResourceTraversalUtil.forEach(new ZipInputStream(jarURL.openStream()), (ResourceHandler) (path, is) -> {
            try {
                if (count < 10) {
                    System.out.println(path);

        assertEquals("url cannot be null", e.getMessage());
    }

    @Test
    void testGetInputStream() throws Exception {
        URL txtFile = new File("target/test-classes/source.txt").toURI().toURL();
        UrlSource source = new UrlSource(txtFile);
        try (InputStream is = source.getInputStream();
                Scanner scanner = new Scanner(is)) {
            assertEquals("Hello World!", scanner.nextLine());

        dependsOn(configureWrapperTaskName)
        group = "wrapper"
    }

    tasks.register(configureWrapperTaskName) {
        doLast {
            val jsonText = URI("https://services.gradle.org/versions/$label").toURL().readText()
            val versionInfo = Gson().fromJson(jsonText, VersionDownloadInfo::class.java)
            println("updating wrapper to $label version: ${versionInfo.version} (downloadUrl: ${versionInfo.downloadUrl})")

        final URL classURL = ResourceUtil.getResource(classFilePath);
        final URL jarURL = new File(JarFileUtil.toJarFilePath(classURL)).toURI().toURL();
        ClassTraversalUtil.forEach(new ZipInputStream(jarURL.openStream()), (ClassHandler) (packageName, shortClassName) -> {
            if (count < 10) {