@get:Input
                    val propertyName: Property<String>
                }

                override fun obtain(): String? = parameters.run {
                    propertiesFile.get().asFile.takeIf { it.isFile }?.inputStream()?.use {
                        java.util.Properties().apply { load(it) }
                    }?.get(propertyName.get()) as String?
                }
            }

            onProjectsCoupled()

            return withDelegateDynamicCallReportingConfigurationOrder(
                propertyName,
                action = { tryGetProperty(propertyName) },
                resultNotFoundExceptionProvider = { getMissingProperty(propertyName) }
            )
        }

        override fun invokeMethod(name: String, args: Any): Any? {

    }

    private static <T> Collection<T> extractAndValidate(String propertyName, String componentName, SetProperty<T> declared) {
        declared.finalizeValue();
        Collection<T> value = declared.get();
        assertNonEmpty(propertyName, componentName, value);
        return value;
    }

    private static void assertNonEmpty(String propertyName, String componentName, Collection<?> property) {

            for (final Map.Entry<String, Object> entry : httpClientPropertyMap.entrySet()) {
                final String propertyName = entry.getKey();
                if (beanDesc.hasPropertyDesc(propertyName)) {
                    final PropertyDesc propertyDesc = beanDesc.getPropertyDesc(propertyName);
                    propertyDesc.setValue(closeableHttpClient, entry.getValue());
                } else {

        delegate.beforeEvaluate(action)

    override fun beforeEvaluate(closure: Closure<*>) =
        delegate.beforeEvaluate(closure)

    override fun property(propertyName: String): Any? =
        delegate.property(propertyName)

    override fun buildscript(configureClosure: Closure<*>) =
        delegate.buildscript(configureClosure)

    override fun getProject(): Project =
        delegate.project

        when:
        withEntryPoint(GET_PROPERTY, propertyName) {
            property = instance.metaClass.getMetaProperty(propertyName)
        }

        then:
        property != null
        (property instanceof CallInterceptingMetaClass.InterceptedMetaProperty) == shouldIntercept

        where:
        propertyName | shouldIntercept
        "testString" | true
        "metaClass"  | false

            String propertyName = request.getInterceptedCallable().getCallableName();
            String setterName = "set" + TextUtil.capitalize(propertyName);
            scopeExpressions.add(CodeBlock.of("$1T.writesOfPropertiesNamed($2S)", INTERCEPTED_SCOPE_CLASS, propertyName));

        }
        return null;
    }

    private static String toMethodName(String prefix, String propertyName) {
        assert !propertyName.isEmpty();
        return prefix + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
    }

    public static Set<String> propertyNames(Object target) {
        Class<?> targetType = target.getClass();

        changedFiles.collectMany { propertyName, files ->
            files.collect { file ->
                "${type} property '${propertyName}' file ${file.absolutePath} has changed.".toString()
            }
        }
    }

    List<String> filesAdded(Map<String, List<File>> addedFiles) {
        addedFiles.collectMany { propertyName, files ->
            files.collect { file ->

                'Use a URI or URL instance',
                'Use a TextResource instance',
            ]
            additionalData.asMap == [
                'typeName': 'org.gradle.api.DefaultTask',
                'propertyName': 'input',
            ]
        }

        where:
        method | targetType
        "dir"  | "directory"
        "file" | "file"
    }