PropertyExpression fullExpression = hasSinglePropertyExpressionArgument(call);
                                if (fullExpression != null) {
                                    // <versionCatalog>.plugins.someId
                                    // or <versionCatalog>.plugins.some.id
                                    // because the expression might be complex we rely on its textual representation

val cachesCleanerService = gradle.sharedServices.registerIfAbsent("cachesCleaner", CachesCleaner::class) {
    parameters.gradleVersion = moduleIdentity.version.map { it.version }
    parameters.homeDir = intTestHomeDir
}

fun Gradle.rootBuild(): Gradle = parent.let { it?.rootBuild() ?: this }

tasks.withType<DistributionTest>().configureEach {
    shouldRunAfter("test")

    setJvmArgsOfTestJvm()

        assert client
        properties.put('signing.gnupg.executable', client.executable)
        properties.put('signing.gnupg.useLegacyGpg', (client.version == 1).toString())
        properties.put('signing.gnupg.homeDir', gpgHomeSymlink.toAbsolutePath().toString())
        properties.remove('signing.gnupg.optionsFile')
        properties.store(buildDir.file('gradle.properties').newOutputStream(), '')

        return gpgHomeSymlink
    }

  Person getFather()

// tag::property-type-managedset[]
  ModelSet<Person> getChildren()
// end::property-type-managedset[]

// tag::property-type-file[]
  void setHomeDirectory(File homeDir)
  File getHomeDirectory()
// end::property-type-file[]

// tag::property-type-long[]
  void setId(Long id)
  Long getId()
// end::property-type-long[]

// tag::property-type-enum[]

)

type LocalGroupUserInfo0 struct {
	Name *uint16
}

type UserInfo4 struct {
	Name            *uint16
	Password        *uint16
	PasswordAge     uint32
	Priv            uint32
	HomeDir         *uint16
	Comment         *uint16
	Flags           uint32
	ScriptPath      *uint16
	AuthFlags       uint32
	FullName        *uint16
	UsrComment      *uint16
	Parms           *uint16

        graphNotifyOps[2].parentId == treeTaskGraphOps[1].id

        where:
        settings                     | display
        ""                           | "default root project name"
        "rootProject.name='someLib'" | "configured root project name"
    }

    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "Also covered by tests in configuration cache project")

    }

    @Test
    @ToBeFixedForConfigurationCache
    void classpathContainsConflictResolvedDependencies() {
        def someLib1Jar = mavenRepo.module('someGroup', 'someLib', '1.0').publish().artifactFile
        def someLib2Jar= mavenRepo.module('someGroup', 'someLib', '2.0').publish().artifactFile

        def settingsFile = file("settings.gradle")
        createDirs("one", "two")
        settingsFile << """

// it returns standard kube cache dir.
func getDefaultCacheDir() string {
	if kcd := os.Getenv("KUBECACHEDIR"); kcd != "" {
		return kcd
	}

	return filepath.Join(homedir.HomeDir(), ".kube", "cache")
}

// ToRESTMapper returns a mapper.
func (f *ConfigFlags) ToRESTMapper() (meta.RESTMapper, error) {
	if f.usePersistentConfig {
		return f.toPersistentRESTMapper()
	}

        taskOps.last().parentId == runTasksOps[1].id

        where:
        settings                     | display
        ""                           | "default root project name"
        "rootProject.name='someLib'" | "configured root project name"
    }

    def "does not resolve configurations when configuring buildSrc build"() {
        when:
        succeeds()

        then:

            final File homeDir = new File(buildDefinition.getBuildRootDir(), "gradleHome");
            return new TestBuildScopeServices(buildTree.getServices(), homeDir, supplier);
        }

        @Override
        public BuildScopeServices getBuildServices() {
            return super.getBuildServices();