MavenProject project = mock(MavenProject.class);
        when(project.getGroupId()).thenReturn("org.apache.maven");
        when(project.getArtifactId()).thenReturn("maven-embedder");
        when(project.getPackaging()).thenReturn("jar");
        when(project.getName()).thenReturn("Apache Maven Embedder");
        when(project.getVersion()).thenReturn("3.5.4-SNAPSHOT");

        then:
        0 * _

        when:
        broadcast.something("12")

        then:
        1 * created.run()
        1 * listener.something("12")
        0 * _
    }

    def "automatically registers stateful listener when first event is broadcast from child"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:

    // Documents existing behaviour. The absolute path of the input artifact is baked into the workspace identity
    // for incremental transforms, and so when the path changes the outputs are invalidated
    def "can attach #description to input artifact property with incrementally transformed artifact but it has no effect when not caching"() {
        createDirs("a", "b", "c")
        settingsFile << "include 'a', 'b', 'c'"
        setupBuildWithColorTransform()

    }

    def "minHeapSize is updated when set using jvmArgs"() {
        when:
        options.minHeapSize = '64m'
        options.jvmArgs('-Xms128m')

        then:
        options.minHeapSize == '128m'

        when:
        options.allJvmArgs = []

        then:
        options.minHeapSize == null

        when:
        options.allJvmArgs = ['-Xms92m']

        then:

            }
        """
        when:
        withBuildCache().run "jacocoTestReport"
        then:
        executedAndNotSkipped ":test", ":jacocoTestReport"
        reportFile.assertIsFile()

        when:
        succeeds "clean"
        then:
        reportFile.assertDoesNotExist()

        when:
        withBuildCache().run("integrationTest", "jacocoIntegrationTestReport")

        when:
        expectResourceRead(name, "12345")
        def result = resource.writeToIfPresent(file)

        then:
        result.bytesRead == 5
        file.text == "12345"
        0 * _

        when:
        expectResourceRead(name, "hi")
        result = resource.writeTo(file)

        then:

    def onOutputWritesText() {
        when:
        output.onOutput('some message')

        then:
        output.value == 'some message'
    }

    def writesNullText() {
        when:
        output.text(null)

        then:
        output.value == 'null'
    }

    def writesEndOfLine() {
        when:
        output.println()

        then:

    def "setup"() {
        settingsFile << "rootProject.name = 'projectConfigure'"
    }

    def "produces reasonable error message when Gradle.beforeProject closure fails"() {
        when:
        settingsFile << """
    gradle.beforeProject {
        throw new RuntimeException("beforeProject failure")
    }
"""
        buildFile << """
    task test
"""
        then:

	basePrincipal := ruleList{}

	// Each condition in the when needs to be consolidated into either permission or principal.
	for _, when := range r.When {
		k := when.Key
		switch {
		case k == attrDestIP:
			basePermission.appendLast(destIPGenerator{}, k, when.Values, when.NotValues)
		case k == attrDestPort:
			basePermission.appendLast(destPortGenerator{}, k, when.Values, when.NotValues)
		case k == attrConnSNI:

        def failure = new RuntimeException()

        when:
        expectSettingsBuiltWithFailure(failure)

        def controller = this.controller()
        controller.loadSettings()

        then:
        def t = thrown RuntimeException
        t == failure

        when:
        def finishResult = controller.finishBuild(null)

        then: