solutions == [ 'Use type \'java.net.URI\' instead' ]
            additionalData.asMap == [
                'typeName' : 'MyTask',
                'propertyName' : 'direct',
            ]
        }
        verifyAll(receivedProblem(1)) {
            fqid == 'validation:property-validation:unsupported-value-type-for-input'

public interface DynamicLookupRoutine {
    @Nullable Object property(DynamicObject receiver, String propertyName) throws MissingPropertyException;
    @Nullable Object findProperty(DynamicObject receiver, String propertyName);
    void setProperty(DynamicObject receiver, String name, @Nullable Object value);
    boolean hasProperty(DynamicObject receiver, String propertyName);
    @Nullable Map<String, ?> getProperties(DynamicObject receiver);

                'Mark it as @Internal',
            ]
            additionalData.asMap == [
                'parentPropertyName' : 'tree',
                'typeName' : 'MyTask',
                'propertyName' : 'nonAnnotated',
            ]
        }

    }

    def "task cannot have property with annotation @#ann.simpleName"() {
        javaTaskSource << """
            import org.gradle.api.*;

        String propertyName = getPropertyName(method);
        Type originalType = extractOriginalType(method, annotation);
        String methodName;
        switch (accessorType) {
            case GETTER:
                String capitalize = propertyName.substring(0, 1).toUpperCase(Locale.ROOT) + propertyName.substring(1);

        abstract String expectedPropertyOutput()

        protected static String echoTaskForProperty(String propertyName) {
            """
                task echo(type: DefaultTask) {
                    def property = providers.gradleProperty('$propertyName')
                        doFirst {
                            println("$propertyName: " + property.orNull)
                        }
                    }
            """
        }

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

        }
        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)

) : InstrumentedExecutionAccess.Listener {

    override fun disallowedAtExecutionInjectedServiceAccessed(injectedServiceType: Class<*>, propertyName: String, consumer: String) {
        executionAccessChecker.disallowedAtExecutionInjectedServiceAccessed(injectedServiceType, propertyName, consumer)
    }

            .typeName("foo")
            .propertyName("bar")
            .build()

        expect:
        DefaultTypeAwareProblemBuilder.introductionFor(Optional.of(data), true) == "Property 'bar' "
    }

    def "render introduction with type"() {
        given:
        def data = DefaultTypeValidationData.builder()
            .typeName("foo")
            .propertyName("bar")
            .build()

        expect:

        file("$folder/src/main/java/${pluginName}.java") << """
            import org.gradle.api.*;

            public class $pluginName implements Plugin<Project> {
                @Override
                public void apply(Project project) {
                    String returned = System.getProperty("$propertyName");