standardOutput.toString().findAll(OUT).size() == 1
        standardError.toString().findAll(OUT).size() == 0
        if (isCompatibleVersion('4.7')) {
            // Handling of error log messages changed
            standardOutput.toString().findAll(ERR).size() == 1
            standardError.toString().findAll(ERR).size() == 0
        } else {
            standardError.toString().findAll(ERR).size() == 1

    private final Amount<Q> average;
    private final Amount<Q> median;
    private final Amount<Q> max;
    private final Amount<Q> min;
    // https://en.wikipedia.org/wiki/Standard_error
    private final Amount<Q> standardError;

    public DataSeries(Iterable<? extends Amount<Q>> values) {
        for (Amount<Q> value : values) {
            if (value != null) {
                add(value);
            }
        }

        this.jvmArgs = jvmArgs;
        this.injectedClassPath = injectedClassPath;
        this.embedded = embedded;
        this.standardOutput = standardOutput;
        this.standardError = standardError;
        this.standardInput = standardInput;
        this.environment = environment;
    }

    public GradleProvider getGradleProvider() {
        return gradleProvider;
    }

    public File getGradleUserHome() {

        1 * connection.run(Void, _) >> {args ->
            ConsumerOperationParameters params = args[1]
            assert params.tasks == []
            assert params.standardOutput == null
            assert params.standardError == null
            assert params.standardInput == null
            assert params.javaHome == null
            assert params.jvmArguments == null
            assert params.arguments == null

        then:
        1 * testKitDirProvider.getDir() >> gradleUserHomeDir
        1 * gradleExecutor.run({ it.standardError == null && it.standardOutput != null }) >> new GradleExecutionResult(BUILD_OPERATION_PARAMETERS, "", null)
    }

    def "standard error is passed on to executor"() {
        given:
        def standardError = new StringWriter()
        def gradleUserHomeDir = testDirectoryProvider.createDir('some/dir')

        def series = new DataSeries([v1, v2, v3])

        expect:
        series.average == v2
        series.median == v2
        series.min == v1
        series.max == v3
        series.standardError == DataAmount.bytes(8360.92)
    }

    def "ignores null values"() {
        def v1 = DataAmount.kbytes(10)
        def v2 = DataAmount.kbytes(20)
        def v3 = DataAmount.kbytes(30)

        def stderr = new ByteArrayOutputStream()

        when:
        withConnection { connection ->
            def build = connection.newBuild()
            build.standardOutput = stdout
            build.standardError = stderr
            build.run()
        }

        then:
        stdout.toString().contains('this is stdout')
        stdout.toString().contains('A warning using SLF4j')

                    assert operation.standardOutput.count("out=hasta la vista") == 1

                    assert operation.standardError.contains("err=hasta la vista $idx")
                    assert operation.standardError.count("err=hasta la vista") == 1
                }
            }
            concurrent.finished()
        }

        then:
        noExceptionThrown()

    }

    protected
    fun assertHasMisorderedChanges(changes: List<Change>? = null) {
        val standardError = StringWriter()
        run(":verifyAcceptedApiChangesOrdering")
            .forwardStdError(standardError)
            .buildAndFail()

        val files = listOf(firstAcceptedApiChangesFile, secondAcceptedApiChangesFile)

        this.operation.standardOutput = stdout
        this.operation.standardError = stderr
    }

    String getStandardOutput() {
        return stdout.toString()
    }

    String getStandardError() {
        return stderr.toString()
    }

    ExecutionResult getResult() {
        return OutputScrapingExecutionResult.from(standardOutput, standardError)
    }

    ConfigurableOperation setStandardInput(String input) {