.build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "protected area"))))
  }

  @Test fun basicChallengeWithCharset() {
    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\", charset=\"UTF-8\"")
        .build()

        Plugin plugin = createPlugin(pluginProject);

        plugin.addDependency(createDependency(pluginLevelDepProject));

        Build build = declaringProject.getModel().getBuild();

        build.addPlugin(plugin);

        declaringProject.getModel().setBuild(build);

        projects = new ProjectSorter(projects).getSortedProjects();

        assertEquals(parentProject, projects.get(0));

        .code(HttpURLConnection.HTTP_MOVED_TEMP)
        .setHeader("Location", otherServer.url("/"))
        .build(),
    )
    otherServer.enqueue(
      MockResponse
        .Builder()
        .headersDelay(500, TimeUnit.MILLISECONDS)
        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)

import org.apache.maven.project.MavenProject;

/**
 * Summarizes the result of a failed project build in the reactor.
 *
 */
public class BuildFailure extends BuildSummary {

    /**
     * The cause of the build failure.
     */
    private final Throwable cause;

    /**
     * Creates a new build summary for the specified project.
     *

                .build());
        options.addOption(Option.builder(FAIL_NEVER)
                .longOpt("fail-never")
                .desc("NEVER fail the build, regardless of project result")
                .build());
        options.addOption(Option.builder(RESUME)
                .longOpt("resume")
                .desc(

    }

    /**
     * @deprecated use {@link #build(ReaderSupplier)}
     */
    @Deprecated
    public PluginDescriptor build(Reader reader) throws PlexusConfigurationException {
        return build(reader, null);
    }

    /**
     * @deprecated use {@link #build(ReaderSupplier, String)}
     */
    @Deprecated
    public PluginDescriptor build(Reader reader, String source) throws PlexusConfigurationException {

        .serialNumber(100L)
        .build()
    val certA1Sha256Pin = pin(certA1.certificate)
    val certB1 =
      HeldCertificate
        .Builder()
        .serialNumber(200L)
        .build()
    val certB1Sha256Pin = pin(certB1.certificate)
    val certC1 =
      HeldCertificate
        .Builder()
        .serialNumber(300L)
        .build()

            "failed-report-with-leftover/build/tmp/teŝt files",
            "successful-report/build/tmp/teŝt files",
            "failed-test-with-leftover/build/tmp/teŝt files"
        )
    }

    @Test
    fun `build does not fail if a flaky test has leftover files`() {
        val result = run(":flaky-test-with-leftover:test", "--no-watch-fs").build()

    val builtRequestWithoutCache = requestWithoutCache.newBuilder().url("http://localhost/api/foo").build()
    assertThat(builtRequestWithoutCache.url).isEqualTo(
      "http://localhost/api/foo".toHttpUrl(),
    )
    val requestWithCache =
      Request
        .Builder()
        .url("http://localhost/api")
        .build()
    // cache url object

	AfterExpression     Expression
	Expression          Expression
	Builder             ClauseBuilder
}

// Build build clause
func (c Clause) Build(builder Builder) {
	if c.Builder != nil {
		c.Builder(c, builder)
	} else if c.Expression != nil {
		if c.BeforeExpression != nil {
			c.BeforeExpression.Build(builder)
			builder.WriteByte(' ')
		}

		if c.Name != "" {
			builder.WriteString(c.Name)