buildTimestampFromGradleProperty.isPresent -> "from buildTimestamp property"
                runningInstallTask.get() -> "from current time because installing"
                runningDocsTestTask.get() -> "from current time because testing docs"
                runningOnCi.get() -> "from current time because CI"
                else -> "from current date"
            }
        }

    private

// type T1[P any] P
// 
// func (T1[_]) m() {}
// 
// func _[P any](x *T1[P]) {
//         // x.m exists because x is of type *T1 where T1 is a defined type
//         // (even though under(T1) is a type parameter)
//         x.m()
// }


func _[P interface{ m() }](x P) {
        x.m()
        // (&x).m doesn't exist because &x is of type *P
        // and pointers to type parameters don't have methods

  String() : String("") {}
  String(const String& s) : value_(s.value_) {}

  // This is the same as the default equality operator, which works because
  // we're interning all strings. It is specified here so we are explicit about
  // it. We're not saying "= default;" because we can't use C++20 features yet.
  bool operator==(const String& other) const { return value_ == other.value_; }

import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache

class BuildSrcEventsIntegrationTest extends AbstractIntegrationSpec {
    @UnsupportedWithConfigurationCache(because = "uses buildFinished")
    def "buildSrc build finished hook is executed after running main tasks and before root build build finished hook"() {
        file("buildSrc/build.gradle") << """

        substitute module("org.utils:util:2.5") using project(":util")
    }
}
// end::module_to_project_substitution[]
// tag::project_to_module_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute project(":api") using module("org.utils:api:1.3") because "we use a stable version of org.utils:api"

# because it won't know that it has to link against a/libb.a
# (because we don't gather the #cgo LDFLAGS from all transitively
# imported packages).
#
# The _cgo_import.go file is only needed for internal linking.
# When generating _cgo_import.go for package c fails, an ordinary
# external link should still work. But an internal link is expected
# to fail, because the failure to create _cgo_import.go should cause

    implementation(libs.commonsLang)
    implementation(libs.groovy)
    implementation(libs.slf4jApi)

    testFixturesApi(project(":base-services")) {
        because("Test fixtures export the Named class")
    }
    testFixturesApi(project(":platform-base")) {
        because("Test fixtures export the Platform class")
    }

    testFixturesImplementation(project(":internal-integ-testing"))

	},
	Score: config.PluginSet{
		Enabled: []config.Plugin{
			// Weight is tripled because:
			// - This is a score coming from user preference.
			// - Usage of node tainting to group nodes in the cluster is increasing becoming a use-case
			// for many user workloads
			{Name: names.TaintToleration, Weight: 3},
			// Weight is doubled because:
			// - This is a score coming from user preference.

    implementation(kotlin("gradle-plugin"))
    implementation(kotlin("compiler-embeddable") as String) {
        because("Required by IncubatingApiReportTask")
    }
    implementation("com.gradle:develocity-gradle-plugin") {
        because("Arch-test plugin configures the PTS extension")
    }

    testImplementation("org.junit.jupiter:junit-jupiter-engine")

println 'This is executed during the configuration phase.'

tasks.register('configured') {
    println 'This is also executed during the configuration phase, because :configured is used in the build.'
}

tasks.register('test') {
    doLast {
        println 'This is executed during the execution phase.'
    }
}

tasks.register('testBoth') {
	doFirst {
	  println 'This is executed first during the execution phase.'
	}
	doLast {