.withBinding("classesUpToDate", "" + classesUpToDate)
            .create().generate()
        projectLayoutSetupRegistry.templateOperationFactory.newTemplateOperation()
            .withTemplate(templateFolder.template("build.sample.conf"))
            .withTarget(settings.target.file("../tests/build.sample.conf").asFile)
            .create().generate()
    }

    private

    val generatedBucketsJson = File(System.getProperty("outputBucketSplitJson", "./test-buckets.json"))

    FunctionalTestBucketGenerator(model, testClassDataJson).generate(generatedBucketsJson)
}

class TestClassTime(
    val testClassAndSourceSet: TestClassAndSourceSet,
    val buildTimeMs: Int
) {
    constructor(jsonObject: JSONObject) : this(
        TestClassAndSourceSet(

        resolver("${prefix}TestAgentsClasspath", LibraryElements.JAR)
    }

    // do not attempt to find projects when the plugin is applied just to generate accessors
    if (project.name != "gradle-kotlin-dsl-accessors" && project.name != "test" /* remove once wrapper is updated */) {
        dependencies {

## Develop and verify

After you make a change, you can run `mvn clean teamcity-configs:generate` to generate and verify the generated TeamCity configuration XMLs.

You also need to run `mvn clean verify` with Java 8 before committing changes.

    "linux" : 596
  }, {
    "testProject" : "largeMonolithicJavaProject",
    "linux" : 178
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.java.JavaDependencyReportPerformanceTest.generate dependency report",
  "durations" : [ {
    "testProject" : "largeJavaMultiProject",
    "linux" : 395
  }, {
    "testProject" : "largeMonolithicJavaProject",
    "linux" : 200
  } ]
}, {

name: Submit Dependency Graph
on:
  workflow_dispatch:
  push:
    branches:
      - master

permissions: {}

jobs:
  generate-and-submit:
    permissions:
      contents: write
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: 11
    - name: Setup Gradle

author:
  using_gitstream: {{ (pr.author | isEnabledUser ) }}

# Perhaps a task could generate this list from the CODEOWNERS, or both this and CODEOWNERS could be generated from different single source of truth?
# Keys like `- build_infrastructure:` do not mean anything, they just need to be unique

<!-- This is a generated file. Use `./gradlew :architectureDoc` to generate -->
# Gradle platform architecture
```mermaid
    graph TD

subgraph core["core platform"]

core_runtime["core-runtime module"]
style core_runtime stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px;

core_configuration["core-configuration module"]
style core_configuration stroke:#1abc9c,fill:#b1f4e7,stroke-width:2px;

core_execution["core-execution module"]

When the Kotlin DSL was introduced, we made an effort to add non-Groovy equivalents for all APIs.
This has been mostly done, but there remain a few holdouts (fixing these is out of scope).

To keep the Groovy DSL ergonomic, we generate methods as necessary from the non-Groovy equivalents.

Doing this provides the following specific benefits:
- **Reduce the API surface** - We no longer need to maintain two methods.

    @Input
    val projects = projectDependencies.elements.map { it.map { it.toGradleModuleName() }.sorted() }

    @get:OutputFile
    abstract val manifestFile: RegularFileProperty

    @TaskAction
    fun generate() {
        ReproduciblePropertiesWriter.store(createProperties(), manifestFile.get().asFile)
    }

    private
    fun createProperties() = Properties().also { properties ->