}

    def "instance walker should allow visiting null nested values"() {
        given:
        def instance = new Object() {
            @TestNested
            NestedType getNested() {
                return null
            }
            @TestNested

import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * {@link InstrumentationTypeRegistry} for checking type information for external plugins.
 * It combines data of direct super types that when visiting external plugins classes and Gradle core types data, to calculated final information for external types.
 */
public class ExternalPluginsInstrumentationTypeRegistry implements InstrumentationTypeRegistry {

     * <p>
     * {@link VisitState#getName()} and {@link VisitState#getPath()} may be called during.
     */
    void preDirectory(VisitState state);

    /**
     * Called when visiting a non-directory file.
     * <p>
     * {@link VisitState#getName()}, {@link VisitState#getPath()} and {@link VisitState#getHashBytes()} may be called during.
     */
    void file(VisitState state);

    /**

     *
     * After cleaning up the files, the empty directories are removed as well.
     */
    public void cleanupOutputs(FileSystemSnapshot snapshot) throws IOException {
        // TODO We could make this faster by visiting the snapshot
        for (Map.Entry<String, FileSystemLocationSnapshot> entry : SnapshotUtil.indexByAbsolutePath(snapshot).entrySet()) {
            cleanupOutput(new File(entry.getKey()), entry.getValue().getType());
        }

        this.defaultArtifactAttributes = attributesFactory.mutable();
    }

    @Override
    public void visitArtifactTypes(Consumer<? super ImmutableAttributes> action) {
        // Apply default attributes before visiting
        Consumer<? super ImmutableAttributes> visitor = attributes -> {
            ImmutableAttributes attributesPlusDefaults = attributesFactory.concat(defaultArtifactAttributes.asImmutable(), attributes);

                }
                // else, might be a link which points to nothing, or has been removed while we're visiting, or ...
                throw new GradleException(String.format("Could not list contents of '%s'.", file));
            }
            for (File child : children) {
                if (stopFlag.get()) {

        this.moduleResolveStateFactory = moduleResolveStateFactory;
        this.dependencyGraphBuilder = dependencyGraphBuilder;
    }

    /**
     * Perform a graph resolution, visiting the resolved graph with the provided visitor.
     *
     * <p>We should keep this class independent of
     * {@link org.gradle.api.internal.artifacts.ResolveContext} and

    "testId" : "org.gradle.performance.regression.corefeature.ArchiveTreePerformanceTest.visiting gzip tar trees",
    "groups" : [ {
      "testProject" : "archivePerformanceProject",
      "coverage" : {
        "per_day" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.corefeature.ArchiveTreePerformanceTest.visiting tar trees",
    "groups" : [ {
      "testProject" : "archivePerformanceProject",

        then:
        0 * _

        then:
        result.valueSnapshots as Map == [:]
        result.fileFingerprints as Map == [:]
    }

    def "reuses previous input snapshots when visiting input properties"() {
        def previousSnapshot = Mock(ValueSnapshot)

        when:
        def result = fingerprintInputProperties(ImmutableSortedMap.of("identity", previousSnapshot)) { visitor ->

			}
			return err
		}
	}
	return nil
}

// WalkDir walks the file tree rooted at root, calling fn for each file or
// directory in the tree, including root.
//
// All errors that arise visiting files and directories are filtered by fn:
// see the [fs.WalkDirFunc] documentation for details.
//
// The files are walked in lexical order, which makes the output deterministic