@Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `can configure custom kotlin options on a kotlin-dsl project`() {

        withDefaultSettingsIn("buildSrc")
        val buildSrcBuildScript = withKotlinDslPluginIn("buildSrc")
        withFile("buildSrc/src/main/kotlin/MyDataObject.kt", "data object MyDataObject")
        withBuildScript("println(MyDataObject)")
        buildAndFail("help").apply {

    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `kotlin-dsl plugin in buildSrc and production code using kotlin-gradle-plugin `() {

        KotlinGradlePluginVersions.assumeCurrentJavaVersionIsSupportedBy(kotlinVersion)

        withDefaultSettingsIn("buildSrc")
        withBuildScriptIn(
            "buildSrc",
            """
            import org.jetbrains.kotlin.config.KotlinCompilerVersion

    }

    def setup() {
        executer.withRepositoryMirrors()
        file("buildSrc/settings.gradle.kts") << """
            include("plugin")
        """
        file("buildSrc/build.gradle.kts") << """
            dependencies {
                implementation(project(":plugin"))
            }
        """
    }

    def cleanup() {

Concretely, we add a _convention plugin_ in `buildSrc` to share the integration test setup between multiple subprojects:

====
include::sample[dir="kotlin",files="buildSrc/src/main/kotlin/myproject.java-conventions.gradle.kts[]"]
include::sample[dir="groovy",files="buildSrc/src/main/groovy/myproject.java-conventions.gradle[]"]
====

And apply it in an application project:

====

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization.buildsrc;

import org.gradle.internal.UncheckedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

 *
 * <ul>
 *     <li>All builds in the tree use the root build's cache configuration, once that configuration is available (ie the root build's settings have been evaluated).</li>
 *     <li>If caching is required in non-root build before the root build's configuration is available, that build's own cache configuration will be used.
 *      Once the root build's configuration is available, the build-specific configuration is discarded.

class TaskBooleanOptionIntegrationTest extends AbstractIntegrationSpec {

    def "if not passed, boolean options have default value with #optionName=#value"() {
        given:
        file('buildSrc/src/main/java/SampleTask.java') << taskWithBooleanOptions()
        buildFile << sampleTask()

        when:
        run('sample')

        then:
        outputContains("Value of $optionName: $value")

        }

        withArguments(arguments)
    }


private
fun buildSrcProjectDirOf(scriptFile: File, importedProjectDir: File): File? =
    importedProjectDir.resolve("buildSrc").takeIf { buildSrc ->
        buildSrc.isDirectory && buildSrc.isParentOf(scriptFile)
    }


private
fun hasProjectDependentClassPath(scriptFile: File): Boolean =
    when (kotlinScriptTypeFor(scriptFile)) {

            public BuildOperationDescriptor.Builder description() {
                //noinspection Convert2Lambda
                return BuildOperationDescriptor.displayName("Build buildSrc").
                    progressDisplayName("Building buildSrc").
                    details(
                        new BuildBuildSrcBuildOperationType.Details() {
                            @Override

Concretely, we add a _convention plugin_ in `buildSrc` to share the integration test setup between multiple subprojects:

====
include::sample[dir="kotlin",files="buildSrc/src/main/kotlin/myproject.java-conventions.gradle.kts[]"]
include::sample[dir="groovy",files="buildSrc/src/main/groovy/myproject.java-conventions.gradle[]"]
====

And apply it in an application project:

====