}

        @Override
        public void visitListeners(Action<T> visitor) {
            if (getType().isInstance(handler)) {
                visitor.execute(getType().cast(handler));
            }
        }

        @Override
        public void visitListenersUntyped(Action<Object> visitor) {
            visitor.execute(handler);
        }

        @Override

                dependenciesNormalizer = visitor.normalizer;
                dependenciesDirectorySensitivity = visitor.directorySensitivity;
                dependenciesLineEndingSensitivity = visitor.lineEndingSensitivity;
                DefaultTransform.validateInputFileNormalizer(propertyMetadata.getPropertyName(), dependenciesNormalizer, cacheable, validationContext);
            }
        }

        def filteringClassLoader = new FilteringClassLoader(parent, spec)
        def visitor = Mock(ClassLoaderVisitor)

        when:
        filteringClassLoader.visit(visitor)

        then:
        1 * visitor.visitSpec(spec)
        1 * visitor.visitParent(parent)
    }

    private void withSpec(ClassLoader parent = null, Closure cl) {
        if (parent == null) {

    @Override
    public void visitImplementations(ImplementationVisitor visitor) {
        visitor.visitImplementation(transform.getImplementationClass());
    }

    @Override
    @OverridingMethodsMustInvokeSuper
    public void visitIdentityInputs(InputVisitor visitor) {
        // Emulate secondary inputs as a single property for now

            }
        }

        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.candidate("A String or CharSequence or Character");
            visitor.candidate("Any Number");
            visitor.candidate("A Boolean");
            visitor.candidate("A File");
        }
    }

                    MethodVisitor visitor = visitMethod(Opcodes.ACC_PUBLIC, methodInstrumentationStrategy.methodName, methodInstrumentationStrategy.descriptor, null, null);
                    visitor.visitCode();
                    visitor.visitInsn(Opcodes.RETURN);
                    visitor.visitMaxs(4, 4);
                    visitor.visitEnd();
                }
            }

        ClassDependenciesVisitor visitor = new ClassDependenciesVisitor(new ClassRelevancyFilter(className), reader, interner);
        reader.accept(visitor, ClassReader.SKIP_FRAMES);

        // Remove the "API accessible" types from the "privately used types"
        visitor.privateTypes.removeAll(visitor.accessibleTypes);
        String name = visitor.moduleName != null ? visitor.moduleName : className;

            return EmptySchema.INSTANCE;
        }

        @Override
        public void visit(Visitor visitor) {
            visitor.visitArtifacts(this);
        }

        @Override
        public void visitTransformSources(TransformSourceVisitor visitor) {
            // Should not be called
            throw new UnsupportedOperationException();
        }

        @Override

        result.component == null

        when:
        result.explain(visitor)

        then:
        visitor.toString() == "Could not locate a Windows SDK installation using the Windows registry."
    }

    def "SDK not available when registry dir contains no version directories"() {
        def visitor = new TreeFormatter()
        def dir1 = kitDir("dir1")

        given:

    }

    public abstract TransformWorkspaceResult resolveForWorkspace(File workspaceDir);

    public void visitOutputs(OutputVisitor visitor) {
        executionOutputs.forEach(output -> output.visitOutput(visitor));
    }

    public int size() {
        return executionOutputs.size();
    }

    public static OutputTypeInferringBuilder builderFor(File inputArtifact, File outputDir) {