String getVeryDeepMessage()
}

interface ShallowChildModel extends BaseModel {
    String getShallowMessage()
}

interface SideModel extends BaseModel {
}

interface CompositeModel {
    BaseModel getNested()

        String output() { "output" }
    }

    static trait SimpleResult {
        String simpleResultMethod() { "simpleResultValue" }
    }

    static trait NestedResult {
        Nested getNested() { new Object().withTraits(Nested) }
    }

    static trait Nested {
        String getNestedValue() { "nestedValue" }

        String toString() { "Nested" }
    }

                private final DefaultModel nested
                DefaultCompositeModel(DefaultModel nested) { this.nested = nested }
                BaseModel getNested() { nested }
            }
        """
    }

    def "supports model polymorphism"() {
        given:
        file("plugins/src/main/groovy/my/MyModelBuilder.groovy") << """
            package my

    }

    @Override
    public void report(CrossVersionPerformanceResults results) {
        if (!testIds.add(results.getTestId())) {
            throw new IllegalArgumentException(String.format("Multiple performance test executions with id '%s' found.", results.getTestId()));
        }
        for (DataReporter<CrossVersionPerformanceResults> reporter : reporters) {
            reporter.report(results);
        }

import javax.inject.Inject;

// tag::custom-toolchain-task-with-java[]
abstract class CustomTaskUsingToolchains : DefaultTask() {

    @get:Nested
    abstract val launcher: Property<JavaLauncher> // <1>

    init {
        val toolchain = project.extensions.getByType<JavaPluginExtension>().toolchain // <2>
        val defaultLauncher = javaToolchainService.launcherFor(toolchain) // <3>
        launcher.convention(defaultLauncher) // <4>
    }

Ich habe mehrere Ideen in den beliebtesten Python-Editoren getestet: PyCharm, VS Code, Jedi-basierte Editoren.

Laut der letzten <a href="https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools" class="external-link" target="_blank">Python-Entwickler-Umfrage</a>, deckt das etwa 80 % der Benutzer ab.

            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${Nested.name}

            abstract class ProducerTask: DefaultTask() {
                @get:Nested
                abstract val params: Params

                @TaskAction
                fun run() {
                    params.outFile.get().asFile.writeText("content")
                }
            }

 */

package org.gradle.performance.fixture;

public class PerformanceTestSpec {
    String testId;
    String testClassName;
    Integer runs;
    Integer warmUpRuns;

    public String getTestId() {
        return testId;
    }

    public void setTestId(String testId) {
        this.testId = testId;
    }

    public String getTestClassName() {
        return testClassName;
    }

    val androidStudioHome: Provider<String>,
    @get:Internal
    val androidStudioJvmArgs: List<String>,
    providers: ProviderFactory
) : CommandLineArgumentProvider {

    @get:Optional
    @get:Nested
    val studioInstallationProvider = providers.provider {
        if (autoDownloadAndroidStudio) {
            studioInstallation
        } else {
            null
        }
    }

            import ${DefaultTask.name}
            import ${TaskAction.name}
            import ${Nested.name}

            abstract class SomeTask: DefaultTask() {
                @get:Nested
                abstract val params: Params

                @TaskAction
                fun run() {
                    println("flag = " + params.flag.get())
                }
            }
        """