then:
        def e = thrown(BuildActionFailureException)
        e.cause instanceof RuntimeException
        TextUtil.normaliseLineSeparators(e.cause.message) == """Multiple build operations failed.
    broken: one
    broken: two"""
    }

    def setupBuildWithDependencyResolution() {
        server.start()

        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'

        when:
        coordinator.runCommand(command, "command")

        then:
        DaemonUnavailableException unavailableException = thrown()
        unavailableException.message == 'This daemon is in a broken state and will stop.'
    }

    def "cannot run command after finish command action has failed"() {
        Runnable command = Mock()
        RuntimeException failure = new RuntimeException()

        when:

        return new NoDaemonGradleExecuter(this, testDirectoryProvider, version, buildContext).withWarningMode(null);
    }

    @Override
    boolean worksWith(Jvm jvm) {
        // Milestone 4 was broken on the IBM jvm
        if (jvm.isIbmJvm() && isVersion("1.0-milestone-4")) {
            return false;
        }

        JavaVersion javaVersion = jvm.getJavaVersion();
        if (javaVersion == null) {

     * then the file type of the file metadata is of type
     * {@link org.gradle.internal.file.FileType#Missing}.
     * <p>
     * Such cases include:
     * <ul>
     *     <li>actual missing files</li>
     *     <li>broken symlinks</li>
     *     <li>circular symlinks</li>
     *     <li>named pipes</li>
     * </ul>
     */
    FileMetadata stat(File f);

				break
			}
			brokers = append(brokers, *host)
		}
		if err != nil {
			return cfg, err
		}

		clientAuthCfgVal := getCfgVal(EnvKafkaTLSClientAuth, k, kv.Get(KafkaTLSClientAuth))
		clientAuth, err := strconv.Atoi(clientAuthCfgVal)
		if err != nil {
			return cfg, err
		}

		kafkaArgs := kafka.Config{
			Enabled: enabled,
			Brokers: brokers,

    }

    def "visitor visits causes of multi-cause exception"() {
        def childCause1 = new RuntimeException()
        def childCause2 = new RuntimeException()
        def cause = new DefaultMultiCauseException("broken", childCause1, childCause2)
        def e = new ContextAwareException(cause)

        when:
        e.accept(visitor)

        then:
        1 * visitor.visitCause(cause)
        1 * visitor.endVisiting()

    String name
    // Url written in the Gradle Module Metadata
    String url
    // Url where this file will be published.
    // Normally publishUrl is the same as url, but it can be set differently for testing some broken behavior.
    String publishUrl
    String ext = 'jar'

    FileSpec(String name) {
        this(name, name, name)
    }

    FileSpec(String name, String url) {
        this(name, url, url)
    }

     * The [KtModule] is being removed. Because this event is published before the removal, the [KtModule] can still be accessed to clear
     * caches. It should be removed from any caches managed by the subscriber to avoid stale or broken keys/values.
     */
    REMOVAL,

            Stub(Path),
            Stub(Path),
            'test project'
        )
        def mid = DefaultModuleVersionIdentifier.newId("foo", "bar", "1.0")
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def dep = new DefaultUnresolvedDependencyResult(
            Stub(ComponentSelector), false,
            Stub(ComponentSelectionReason),

  - 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)
    }