super(value);
        this.outputFilePropertyType = outputFilePropertyType;
    }

    @Override
    public TaskOutputFilePropertyBuilder withPropertyName(String propertyName) {
        setPropertyName(propertyName);
        return this;
    }

    @Override
    public TaskOutputFilePropertyBuilder optional() {
        return optional(true);
    }

    @Override

    public boolean interceptsPropertyAccess(String propertyName) {
        return findGetterCallerAndInterceptor(propertyName) != null || findSetterCallerAndInterceptor(propertyName) != null;
    }

    @Nullable
    private Pair<String, CallInterceptor> findGetterCallerAndInterceptor(String propertyName) {
        String caller = callsTracker.findCallerForCurrentCallIfNotIntercepted(propertyName, GET_PROPERTY);
        if (caller == null) {

        def propertiesMetadata = typeMetadata.propertiesMetadata

        then:
        propertiesMetadata.size() == 1
        def propertyMetadata = propertiesMetadata.first()
        propertyMetadata.propertyName == 'searchPath'
        propertyMetadata.propertyType == SearchPath
        typeMetadata.getAnnotationHandlerFor(propertyMetadata) == annotationHandler
        collectProblems(typeMetadata).empty
    }

 */
public interface TypeValidationDataSpec extends AdditionalDataSpec {
    TypeValidationDataSpec pluginId(String pluginId);
    TypeValidationDataSpec propertyName(String propertyName);
    TypeValidationDataSpec parentPropertyName(String parentPropertyName);
    TypeValidationDataSpec typeName(String typeName);

    }

    @Override
    public int getIdleConnectionTimeoutMs() {
        return idleConnectionTimeoutMs;
    }

    private int initTimeout(String propertyName, int defaultValue) {
        String systemProperty = System.getProperty(propertyName);

        if (!StringUtils.isBlank(systemProperty)) {
            try {
                return Integer.parseInt(systemProperty);
            } catch (NumberFormatException e) {

        }
        propertyNamesToCheck.forEach { propertyName ->
            val isPropertyLike =
                preIndex.getAllProperties(returnClass).any { it.name == propertyName }
            if (isPropertyLike) {
                val storeProperty = checkNotNull(preIndex.getProperty(returnClass, propertyName))
                return ParameterSemanticsInternal.DefaultStoreValueInProperty(storeProperty)

            @Override
            public void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {
                context.add(value.getTaskDependencies());
            }

            @Override
            public void visitInputFileProperty(
                final String propertyName,
                boolean optional,
                InputBehavior behavior,

            String propertyName = propertyContext.getName();
            ModelType<?> propertyType = propertyContext.getType();
            if (isManagedCollection(propertyType)) {
                s.append(String.format("Its property '%s %s' is not a valid managed collection%n", propertyType.getName(), propertyName));

    private final TreeType outputType;

    public DefaultCacheableOutputFilePropertySpec(
        String propertyName,
        @Nullable String propertySuffix,
        FileCollectionInternal outputFiles,
        TreeType outputType
    ) {
        super(propertyName, OutputNormalizer.INSTANCE, outputFiles);
        this.propertySuffix = propertySuffix;
        this.outputType = outputType;
    }

@Contextual
public class PropertyEvaluationException extends GradleException {

    public PropertyEvaluationException(Object work, String propertyName, Throwable cause) {
        super(String.format("Error while evaluating property '%s' of %s.", propertyName, work), cause);
    }