sourceSets {
    main {
        java.setSrcDirs(listOf(ant.properties["src.dir"]))
        java.destinationDirectory = file(ant.properties["classes.dir"] ?: layout.buildDirectory.dir("classes"))
    }
}
// end::source-sets[]

// tag::task-dependencies[]
tasks {
    compileJava {
        dependsOn("prepare")  // <1>
    }
    named("package") {
        setDependsOn(listOf(compileJava))  // <2>
    }
    assemble {

        fromString()      | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"
        fromStringArray() | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"
        fromStringList()  | "ProcessGroovyMethods.execute(command, listOf(\"FOOBAR=foobar\"), file(\"$pwd\"))"  | pwd               | "foobar"

        globalExtension.taskPathToReports = taskPathToReports
    }
}

fun Task.customReports(): List<File> = when (this) {
    is ValidatePlugins -> listOf(outputFile.get().asFile)
    is FindBrokenInternalLinks -> listOf(reportFile.get().asFile)
    is DistributionTest -> listOf(
        gradleInstallationForTest.gradleUserHomeDir.dir("test-kit-daemon").get().asFile,

            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi.KtExpression",
                "org.jetbrains.kotlin.psi"
            )
        ),
        KtSourceElement::class to HLFunctionCallConversion(
            "({0} as? KtPsiSourceElement)?.psi",
            PsiElement::class.createType(nullable = true),
            importsToAdd = listOf(
                "org.jetbrains.kotlin.psi",

                        flag.set(true)
                        message.set("some value")
                        number.set(1.23)
                        list.set(listOf(1, 2))
                        set.set(listOf(1, 2))
                        map.set(mapOf(1 to true, 2 to false))
                    }
                }
            }
        """
    }

    @Override

        assertThat(
            defaultPackageTypesIn(listOf("java.util.Map<Key, Value>")),
            equalTo(listOf("Key", "Value"))
        )
    }

    @Test
    fun `#defaultPackageTypesIn (duplicate types)`() {

        assertThat(
            defaultPackageTypesIn(listOf("java.util.Map<Value, Value>")),
            equalTo(listOf("Value"))
        )
    }

                    TypedProjectSchema(
                        extensions = listOf(
                            entry<Project, ExtraPropertiesExtension>("extra")
                        ),
                        conventions = listOf(
                            entry<Project, CustomConvention>("customConvention")
                        ),
                        tasks = listOf(
                            entry<TaskContainer, Delete>("delete")

    def "empty lists are the same"() {
        expect:
        PersistentList.of() == PersistentList.of()
    }

    def "lists with elements #elements are the same"() {
        expect:
        listOf(elements) == listOf(elements)

        where:
        elements << [["a"], ["a", "b"]]
    }

    def "has a nice toString method"() {
        expect:
        PersistentList.of().toString() == "Nil"

        }
    }

    private
    val reportedMembers = listOf(
        "Class" to "AddedClass"
    ) + reportedMembersFor("AddedClass") + listOf(
        "Constructor" to "AddedClass(java.lang.String)",
        "Constructor" to "AddedClass()",
        "Class" to "AddedEnum",
        "Field" to "FOO"
    ) + reportedMembersFor("AddedEnum", isEnum = true) + listOf(
        "Method" to "AddedEnum.valueOf(java.lang.String)",

            "My",
            listOf("My.class", "MyKt.class")
        )

        assertClassFilePathCandidatesFor(
            "foo.My",
            listOf("foo/My.class", "foo/MyKt.class", "foo${'$'}My.class", "foo${'$'}MyKt.class")
        )

        assertClassFilePathCandidatesFor(
            "foo.My.Nested",
            listOf(
                "foo/My/Nested.class", "foo/My/NestedKt.class",