return nil, err
		}
		if !enabled {
			continue
		}
		var brokers []xnet.Host
		brokersEnv := target.EnvKafkaBrokers
		if k != config.Default {
			brokersEnv = brokersEnv + config.Default + k
		}
		kafkaBrokers := env.Get(brokersEnv, kv.Get(target.KafkaBrokers))
		if len(kafkaBrokers) == 0 {
			return nil, config.Errorf("kafka 'brokers' cannot be empty")
		}

            throw new DaemonConnectionException("Could not receive a message from the daemon.", e);
        } finally {
            hasReceived = true;
        }
    }

    /**
     * Treat the connection as probably broken, and leniently handle failures writing outgoing messages.
     */
    public void markSuspect() {
        suspect = true;
    }

    @Override
    public void stop() {

        server.expect("serviceClosed")

        def build = executer.withTasks("b").start()

        handleA.waitForAllPendingCalls()
        // Increase the chance of the test to detect a broken implementation that doesn't wait for events to be processed before closing the service.
        sleep(1000)
        handleA.releaseAll()

        result = build.waitForFinish()

        result2.value.result.serializedModel.size() == 1
        result2.value.failure == null
        result2.value.exception == null

        def buildFailed = BuildActionResult.failed(new RuntimeException("broken"))
        def message3 = new Success(buildFailed)
        def result3 = serialize(message3, serializer)
        result3 instanceof Success
        result3.value instanceof BuildActionResult

     */
    void runCommand(Runnable command, String commandDisplayName) throws DaemonUnavailableException, DaemonStoppedException;

    enum State {Idle, Busy, Canceled, StopRequested, Stopped, ForceStopped, Broken}

# SIGPIPE

When a Go program writes to a broken pipe, the kernel will raise a
SIGPIPE signal.

If the program has not called Notify to receive SIGPIPE signals, then
the behavior depends on the file descriptor number. A write to a
broken pipe on file descriptors 1 or 2 (standard output or standard
error) will cause the program to exit with a SIGPIPE signal. A write
to a broken pipe on some other file descriptor will take no action on

		return true
	case emptySHA256:
		// some broken clients set empty-sha256
		// with > 0 content-length in the body,
		// we should skip such clients and allow
		// blindly such insecure clients only if
		// S3 strict compatibility is disabled.

		// We return true only in situations when
		// deployment has asked MinIO to allow for
		// such broken clients and content-length > 0.

        e.message == "Don't know how to serialize objects of type java.lang.String."
    }

    def "uses serializer registered for Throwable for subtypes of Throwable"() {
        def failure = new IOException("broken")
        def throwableSerializer = Mock(Serializer)

        given:
        _ * throwableSerializer.write(_, failure)
        _ * throwableSerializer.read(_) >> failure

     * Run docs tests with the configuration cache enabled.
     */
    const val ENABLE_CONFIGURATION_CACHE_FOR_DOCS_TESTS = "enableConfigurationCacheForDocsTests"

    /**
     * Run docs tests that are knowingly broken when running with the configuration cache enabled. Only applied when #ENABLE_CONFIGURATION_CACHE_FOR_DOCS_TESTS is also set.
     */
    const val RUN_BROKEN_CONFIGURATION_CACHE_DOCS_TESTS = "runBrokenConfigurationCacheDocsTests"

  }

  /**
   * Returns a {@code Collector} that returns the {@code k} smallest (relative to the specified
   * {@code Comparator}) input elements, in ascending order, as an unmodifiable {@code List}. Ties
   * are broken arbitrarily.
   *
   * <p>For example:
   *
   * <pre>{@code
   * Stream.of("foo", "quux", "banana", "elephant")
   *     .collect(least(2, comparingInt(String::length)))
   * // returns {"foo", "quux"}