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

		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)

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

import java.nio.file.Files

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class WrapperIntegrationTest extends AbstractWrapperIntegrationSpec {
    def "can recover from a broken distribution"() {
        buildFile << "task hello"
        prepareWrapper()
        def gradleUserHome = testDirectory.file('some-custom-user-home')
        when:

            }
        }
    }

    /**
     * Adds a broken resource at the given URL.
     */
    void addBroken(String path) {
        allow(path, true, null, broken())
    }

    /**
     * Expects one GET request, which fails with a 500 status code
     */
    void expectGetBroken(String path) {
        expect(path, false, ['GET'], broken())
    }

    /**

        gradleHandle.waitForFinish()
        gradleHandle.standardOutput.contains("result = true")

        where:
        input    | _
        ""       | _
        "broken" | _
        "false"  | _
        "nope"   | _
        "y"      | _
        "n"      | _
    }

    @ToBeFixedForIsolatedProjects(because = "subprojects")

                throw new RuntimeException("broken")
            }
        """
        repo.commit("initial version")
        repo.createLightWeightTag("1.2")
        dependency(dependencyName)

        when:
        fails(":assemble")

        then:
        failure.assertHasDescription("Execution failed for task ':${buildName}:classes'.")
        failure.assertHasCause("broken")

        where:

	EnvMQTTQueueLimit        = "MINIO_NOTIFY_MQTT_QUEUE_LIMIT"
)

// MQTTArgs - MQTT target arguments.
type MQTTArgs struct {
	Enable               bool           `json:"enable"`
	Broker               xnet.URL       `json:"broker"`
	Topic                string         `json:"topic"`
	QoS                  byte           `json:"qos"`
	User                 string         `json:"username"`