val server =
    MockWebServer().apply {
      useHttps(handshakeCertificates.sslSocketFactory(), false)

      enqueue(
        MockResponse()
          .setResponseCode(HTTP_MOVED_TEMP)
          .setHeader("Location", "https://www.google.com/robots.txt"),
      )
    }

  val clientCertificates =
    HandshakeCertificates.Builder()
      .addPlatformTrustedCertificates()
      .addInsecureHost(server.hostName)

            "0000a6d000603617069c012c0300005000100000cde000c04737461720463313072c012c04200010001000" +
            "0003b00049df00112",
        )
          .newBuilder()
          .setHeader("cache-control", "private, max-age=298")
          .build(),
      )
    }

    var result = cachedDns.lookup("google.com")
    assertThat(result).containsExactly(address("157.240.1.18"))

        return xml.ItemGroup.findAll({ it.'@Label' == 'Filters' })[0]
    }

    private Node getSources() {
        return xml.ItemGroup.find({ it.'@Label' == 'Sources' }) as Node
    }

    private Node getHeaders() {
        return xml.ItemGroup.find({ it.'@Label' == 'Headers' }) as Node
    }

    private String toPath(File it) {
        fileLocationResolver.transform(it)
    }

            new Random().nextBytes(connectionAuth.challenge)
            connections[HttpConnection.currentConnection] = connectionAuth
        }

        if (connectionAuth.failed) {
            httpResponse.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
            httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED)
            return Authentication.SEND_CONTINUE

                return null
            }
        }

        when:
        def request = new HttpGet("http://gradle.org")
        client.performRequest(request, true)

        then:
        request.getHeaders("Cache-Control")[0].value == "max-age=0"
    }

    def "stripping user credentials removes username and password"() {
        given:
        def uri = new URI("https", "admin:password", "foo.example", 80, null, null, null)

            @Override
            public List<SourceFile> getAfterFiles() {
                List<SourceFile> result = new ArrayList<SourceFile>();
                result.addAll(beforeElement.getHeaders().getFiles());
                result.add(afterFile);
                return result;
            }
        };
    }

			g.Expect(len(routes)).To(Equal(1))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetName()).To(Equal("FOO-HEADER"))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetPresentMatch()).To(Equal(true))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetInvertMatch()).To(Equal(false))
			g.Expect(routes[0].GetMatch().GetHeaders()[0].GetTreatMissingHeaderAsEmpty()).To(Equal(false))
		}
	})

    public String toString() {
        return "prebuilt library '" + name + "'";
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public SourceDirectorySet getHeaders() {
        return headers;
    }

    @Override
    public DomainObjectSet<NativeLibraryBinary> getBinaries() {
        return binaries;
    }

    public abstract SourceElement getPublicHeaders();

    public SourceElement getPrivateHeaders() {
        return empty();
    }

    @Override
    public SourceElement getHeaders() {
        return ofElements(getPublicHeaders(), getPrivateHeaders());
    }

    /**
     * Returns a copy of this library with the public headers the 'public' headers directory.
     */

              if (42 == 42) {
                return 0;
              }
              return -1;
            }"""),
    ]

    List<SourceFile> headerFiles = []

    @Override
    SourceElement getHeaders() {
        return ofElements(sum.headers)
    }

    @Override
    SourceElement getSources() {
        return ofElements(sum.sources, sumTest.sources)
    }

    @Override