def visitor = Mock(PropertyVisitor)
    def validationContext = Mock(TypeValidationContext)

    def "visits properties"() {
        def task = project.tasks.create("myTask", MyTask)

        when:
        visitProperties(task)

        then:
        _ * visitor.visitOutputFilePropertiesOnly() >> false
        1 * visitor.visitInputProperty('myProperty', { it.call() == 'myValue' }, false)

        this.deprecatedThis = new TaskInputsDeprecationSupport();
    }

    @Override
    public boolean getHasInputs() {
        HasInputsVisitor visitor = new HasInputsVisitor();
        TaskPropertyUtils.visitProperties(propertyWalker, task, visitor);
        return visitor.hasInputs();
    }

    @Override
    public void visitRegisteredProperties(PropertyVisitor visitor) {

     */
    // TODO Move this to some test fixture like TaskPropertyTestUtils
    @VisibleForTesting
    public static void visitProperties(PropertyWalker propertyWalker, TaskInternal task, PropertyVisitor visitor) {
        visitProperties(propertyWalker, task, TypeValidationContext.NOOP, visitor);
    }

    /**

import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Walks properties declared by the type.
 */
@ServiceScope(Scope.Global.class)
public interface PropertyWalker {
    void visitProperties(Object instance, TypeValidationContext validationContext, PropertyVisitor visitor);

    }

    static Map<String, Object> getProperties(TaskInternal task, PropertyWalker propertyWalker) {
        GetInputPropertiesVisitor visitor = new GetInputPropertiesVisitor()
        TaskPropertyUtils.visitProperties(propertyWalker, task, visitor)
        return visitor.getProperties().collectEntries { [it.propertyName, it.value.call()] }
    }

    static FileCollection getInputFiles(DefaultTask task) {

        def visitor = new GetInputPropertiesVisitor()
        TaskPropertyUtils.visitProperties(walker, task, visitor)
        return visitor.properties.collectEntries { [it.propertyName, InputParameterUtils.prepareInputParameterValue(it.value)] }
    }

    def inputFileProperties() {
        def inputFiles = [:]
        TaskPropertyUtils.visitProperties(walker, task, new PropertyVisitor() {
            @Override

        pluginTarget.applyImperative(null, plugin)

        then:
        1 * softwareTypeRegistry.isRegistered(_) >> true
        1 * inspectionScheme.getPropertyWalker() >> propertyWalker
        1 * propertyWalker.visitProperties(plugin, _, _) >> { args -> args[2].visitSoftwareTypeProperty("foo", propertyValue, softwareType) }
        1 * target.getExtensions() >> extensions
        1 * softwareType.modelPublicType() >> Foo.class

    public boolean getHasOutput() {
        if (!upToDateSpec.isEmpty()) {
            return true;
        }
        HasDeclaredOutputsVisitor visitor = new HasDeclaredOutputsVisitor();
        TaskPropertyUtils.visitProperties(propertyWalker, task, visitor);
        return visitor.hasDeclaredOutputs();
    }

    @Override
    public FileCollection getFiles() {
        return allOutputFiles;
    }

        }
    }

    private
    fun <P : FlowParameters> validate(type: Class<P>, parameters: P) {
        val problems = ImmutableList.builder<Problem>()
        inspection.propertyWalker.visitProperties(
            parameters,
            object : ProblemRecordingTypeValidationContext(type, { Optional.empty() }) {
                override fun recordProblem(problem: Problem) {
                    problems.add(problem)

        this.handlers = propertyHandlers.stream().collect(toImmutableMap(PropertyAnnotationHandler::getAnnotationType, Function.identity()));
    }

    @Override
    public void visitProperties(Object bean, TypeValidationContext validationContext, PropertyVisitor visitor) {
        walker.walk(bean, new TypeMetadataWalker.InstanceMetadataVisitor() {
            @Override