&metrics.CounterOpts{
			Namespace:      namespace,
			Subsystem:      subsystem,
			Name:           "port_errors_total",
			Help:           "Number of errors detected on ports by the repair loop broken down by type of error: leak, repair, full, outOfRange, duplicate, unknown",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"type"},
	)

        buildA.file("a/build.gradle") << """
            plugins { id("java-gradle-plugin") }
            gradlePlugin {
                plugins {
                    broken {
                        id = "a-plugin"
                        implementationClass = "org.test.Broken"
                    }
                }
            }
        """
        buildA.file("b/build.gradle") << """
            plugins {

  - A Directory instance.
  - A RegularFile instance.
  - A URI or URL instance.
  - A TextResource instance."""

        when:
        fails "broken"
        then:
        executedAndNotSkipped ":broken"
        failureDescriptionContains("Execution failed for task ':broken'.")
        failureCauseContains(cause)
    }

                        module('org.test:dont-ignore-me:1.0')
                    }
                }
            }
        }
    }

    @ToBeFixedForConfigurationCache(because = "broken file collection")
    def "when no target configuration is specified then a dependency on maven module includes the runtime dependencies of target project that is using the Java plugin"() {

        repoC.file("settings.gradle") << """
            ${settings}
        """
        repoC.file("build.gradle") << """
            classes.doLast {
                throw new RuntimeException("broken")
            }
        """
        repoC.commit("initial version")
        repoC.createLightWeightTag("1.2")

        dependency(dependencyName)
        repoB.commit("initial version")

		expectCreateErr   bool
		expectAllocation  []string
		expectAllocateErr bool
	}{
		"empty": {},

		"broken-filter": {
			filter: filterBrokenType,

			expectCreateErr: true,
		},

		"broken-request": {
			requests: []*resourceapi.NamedResourcesRequest{requestBrokenType},

			expectCreateErr: true,
		},

		"no-resources": {

        models[1] instanceof CustomModel
    }

    def "listener is isolated when it fails with an exception"() {
        when:
        def listener = { throw new RuntimeException("broken") } as StreamedValueListener

        withConnection {
            def builder = it.action(new ModelStreamingBuildAction())
            collectOutputs(builder)
            builder.setStreamedValueListener(listener)

 * capabilities to the default HTTPS handler. This acts as a wrapper,
 * handling authentication and passing control to the underlying
 * stream handler.
 * 
 * @deprecated {@link NtlmHttpURLConnection} is broken by design.
 */
@Deprecated
public class Handler extends jcifs.http.Handler {

    /**
     * The default HTTPS port (<code>443</code>).
     */
    public static final int DEFAULT_HTTPS_PORT = 443;

        replaceBody(new SendFixedContent(404, "not found"), null);
        return this;
    }

    @Override
    public BuildableExpectedRequest broken() {
        replaceBody(new SendFixedContent(500, "broken"), null);
        return this;
    }

    @Override
    public BuildableExpectedRequest send(String content) {
        replaceBody(new SendFixedContent(200, content), null);

    }

    def "serializes Throwable"() {
        def failure = new GradleException("broken", new RuntimeException("cause"))

        when:
        def result = serialize(failure, Throwable)

        then:
        result.class == GradleException
        result.message == "broken"
        result.cause.class == RuntimeException
        result.cause.message == "cause"
    }