"everything has convention and is set"             | setAll("convention", "convention") | setAll("test", "baz") | """id = test\nbar = baz"""
    }

    def "sensible error when conventions are set more than once (#testCase)"() {
        given:
        withSoftwareTypePlugins().prepareToExecute()

└── settings.gradle.kts
----
<1> Create the `myproject.java-conventions` convention plugin.
<2> Applies the `myproject.java-conventions` convention plugin.
=====
[.multi-language-sample]
=====
[source, groovy]
----
.
├── buildSrc
│   ├── src
│   │   └──main
│   │      └──groovy
│   │         └──myproject.java-conventions.gradle  // <1>
│   └── build.gradle
├── api
│   ├── src

            ?: Factory {
                // Find convention
                // Reflective look up to still support plugins that inlined this function once conventions will be removed
                this::class.java.methods.firstOrNull { it.name == "getConvention" }?.invoke(this)?.let { convention ->
                    convention::class.java.getMethod("findPlugin", Class::class.java).invoke(convention, T::class.java)
                }

By sticking to the default conventions, new developers to the project immediately know how to find their way around.
While those conventions can be reconfigured, it makes it harder to build script users and authors to manage the build logic and its outcome.
Try to stick to the default conventions as much as possible except if you need to adapt to the layout of a legacy project.

    val conventions: List<ProjectSchemaEntry<TypeOf<*>>>,
    val tasks: List<ProjectSchemaEntry<TypeOf<*>>>,
    val containerElements: List<ProjectSchemaEntry<TypeOf<*>>>
)


internal
fun targetSchemaFor(target: Any, targetType: TypeOf<*>): TargetTypedSchema {

    val extensions = mutableListOf<ProjectSchemaEntry<TypeOf<*>>>()
    val conventions = mutableListOf<ProjectSchemaEntry<TypeOf<*>>>()

            .addPluginId("org.gradle.repo-conventions", "RepoConventionPlugin")
            .publishAs("g", "a", "1.0", pluginPortal, createExecuter())

        // make sure we don't use the default fixture which already adds repositories
        settingsFile.text = """
            plugins {
                id "org.gradle.repo-conventions" version "1.0"
            }

            rootProject.name = 'test'

        ["project"].toSet() == project.stepResults.keySet().collect { it.stepIdentifier.key }.toSet()

        and: 'conventions get properly applied'
        // check the conventions in the resolution results, they should be there, and it is independent of the DOM overlay
        def projectEvaluated = project.stepResults.values()[0] as EvaluationResult.Evaluated<AnalysisStepResult>

  // with the unique CSI driver name.
  //
  // Objects are namespaced.
  //
  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
  // +optional
  optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // nodeTopology defines which nodes have access to the storage

  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
  // +optional
  optional k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // The desired behavior of this daemon set.
  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
  // +optional
  optional DaemonSetSpec spec = 2;

  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
  // +optional
  optional IngressSpec spec = 2;

  // status is the current state of the Ingress.
  // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
  // +optional
  optional IngressStatus status = 3;
}