public boolean apply(DirectoryTree input) {
                        return input.getDir().exists();
                    }
                })
        );

        for (DirectoryTree fileTree : existing) {
            dynamicObject.invokeMethod(childNodeName, Collections.singletonMap("location", fileTree.getDir()));
        }

        dynamicObject.invokeMethod("or", new Closure<Void>(this) {

                        .id(TextUtil.screamingSnakeToKebabCase(REDUNDANT_GETTERS), "Property has redundant getters", GradleCoreProblemGroup.validation().property()) // TODO (donat) missing test coverage
                        .contextualLabel(
                            String.format(
                                "has redundant getters: '%s()' and '%s()'",
                                previouslySeenBuilder.getter.getName(),

/**
 * Marker interface for parameter objects to {@link TransformAction}s.
 *
 * <p>
 *     Parameter types should be interfaces, only declaring getters for {@link org.gradle.api.provider.Property}-like objects.
 *     All getters must be annotated with an input annotation like {@link org.gradle.api.tasks.Input} or {@link org.gradle.api.tasks.InputFiles}.

import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.primaryConstructor


/**
 * Extracts schema properties from Kotlin properties and Java getters returning the type [Property].
 * Ensures that the return types of these properties get discovered during type discovery.
 */
internal
class GradlePropertyApiAnalysisSchemaComponent : AnalysisSchemaComponent {
    private

)

func NewOOMAdjuster() *OOMAdjuster {
	oomAdjuster := &OOMAdjuster{
		pidLister:        getPids,
		ApplyOOMScoreAdj: applyOOMScoreAdj,
	}
	oomAdjuster.ApplyOOMScoreAdjContainer = oomAdjuster.applyOOMScoreAdjContainer
	return oomAdjuster
}

func getPids(cgroupName string) ([]int, error) {
	return cmutil.GetPids(filepath.Join("/", cgroupName))
}

// Writes 'value' to /proc/<pid>/oom_score_adj. PID = 0 means self

		e.Value = nil
		deductFromQueueSum(&l.sum, req)
		return req
	}
}

func (l *requestFIFO) Dequeue() (*request, bool) {
	return l.getFirst(true)
}

func (l *requestFIFO) Peek() (*request, bool) {
	return l.getFirst(false)
}

func (l *requestFIFO) getFirst(remove bool) (*request, bool) {
	e := l.Front()
	if e == nil {
		return nil, false
	}

	if remove {
		defer func() {

        return toolsByName.get(name);
    }

    @Override
    public Collection<NativeDependencySet> getLibs() {
        return resolve(getInputs().withType(DependentSourceSet.class)).getAllResults();
    }

    @Override
    public Collection<NativeDependencySet> getLibs(DependentSourceSet sourceSet) {
        return resolve(Collections.singleton(sourceSet)).getAllResults();
    }

    @Override

                        def properties = org.gradle.internal.reflect.ClassInspector.inspect(convertedClass).properties
                        properties.each { prop ->
                            if (prop.getters.find { it.declaringClass == convertedClass }) {
                                println "Checking property \${prop.name} on \${convertedClass.name}"

        '''

        then:
        succeeds "echo"

        and:
        output.contains("name: foo")
    }

    def "managed type implemented as abstract class can have generative getters"() {
        when:
        buildScript '''
            @Managed
            abstract class Person {
                abstract String getFirstName()
                abstract void setFirstName(String firstName)

                        SuggestUtil.deleteScrollContext(client, scrollId);
                    }
                }
                scrollId = response.getScrollId();
                final SearchHit[] hits = response.getHits().getHits();
                if (scrollId == null || hits.length == 0) {
                    SuggestUtil.deleteScrollContext(client, scrollId);
                    isFinished.set(true);
                }