def "init"() {
        given:
        def task1 = Mock(Task)
        def task2 = Mock(Task)

        when:
        def publishArtifact = new DefaultPublishArtifact(testName, testExt, testType,
                testClassifier, date, testFile, task1, task2)
        then:
        publishArtifact.buildDependencies.getDependencies(null) == [task1, task2] as Set
        assertCommonPropertiesAreSet(publishArtifact, true)

dependencies {
    jacocoAggregation(project(":application")) // <.>
}

// tag::create_report[]
reporting {
    reports {
        val testCodeCoverageReport by creating(JacocoCoverageReport::class) { // <.>
            testType = TestSuiteType.UNIT_TEST
        }
    }
}
// end::create_report[]

tasks.check {
    dependsOn(tasks.named<JacocoReport>("testCodeCoverageReport")) // <.>

    private val nameToSubproject = subprojects.map { it.name to it }.toMap()
    override fun getSubprojectsForFunctionalTest(testConfig: TestCoverage) =
        subprojects.filter { it.hasTestsOf(testConfig.testType) }

    override fun getSubprojectByName(name: String) = nameToSubproject[name]

    private
    fun toSubproject(subproject: Map<String, Any>): GradleSubproject {
        val name = subproject["name"] as String

    }

    protected String getTestType() {
        TEST_TYPE
    }

    protected String getTestClassifier() {
        TEST_CLASSIFIER
    }

    protected Date getDate() {
        TEST_DATE
    }

    protected void assertCommonPropertiesAreSet(PublishArtifact artifact, boolean shouldHaveClassifier) {
        assert testName == artifact.name
        assert testType == artifact.type

Running the tests and generate the report:

[listing.terminal.sample-command]
----
$ ./gradlew testCodeCoverageReport

BUILD SUCCESSFUL
25 actionable tasks: 25 executed

	err error
}

func (f *fakeReporter) AsObject(err error) runtime.Object {
	f.err = err
	return runtime.Unstructured(nil)
}

func TestStreamWatcher(t *testing.T) {
	table := []Event{
		{Type: Added, Object: testType("foo")},
	}

	fd := fakeDecoder{items: make(chan Event, 5)}
	sw := NewStreamWatcher(fd, nil)

	for _, item := range table {
		fd.items <- item
		got, open := <-sw.ResultChan()
		if !open {

            </tr>
            <tr>
                <td>sources</td>
            </tr>
            <tr>
                <td>targets</td>
            </tr>
            <tr>
                <td>testType</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

}

version = '1.0.2'
group = 'org.gradle.sample'

repositories {
    mavenCentral()
}

// tag::configure-type[]
testing {
    suites {
        secondaryTest(JvmTestSuite) {
            testType = TestSuiteType.INTEGRATION_TEST // <1>
        }
    }
}

version = "1.0.2"
group = "org.gradle.sample"

repositories {
    mavenCentral()
}

// tag::configure-type[]
testing {
    suites {
        val secondaryTest by registering(JvmTestSuite::class) {
            testType = TestSuiteType.INTEGRATION_TEST // <1>
        }
    }
}

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>reportTask</td>
            </tr>
            <tr>
                <td>testType</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>