"-s", iptablesconstants.IPVersionSpecific,
		"-p", "tcp",
		"-m", "tcp",
		"-j", "ACCEPT",
	)

	// CLI: -t NAT -A ISTIO_OUTPUT -d 169.254.7.127 -p tcp -m tcp -j ACCEPT
	// CLI: -t NAT -A ISTIO_OUTPUT -d fd16:9254:7127:1337:ffff:ffff:ffff:ffff -p tcp -m tcp -j ACCEPT
	//
	// DESC: Anything coming BACK from the pod healthcheck port with a dest of our SNAT-ed hostside IP
	// we also short-circuit.

      .assertNoMoreLogs()
    networkLogs
      .assertLogEqual("--> GET $url http/1.1")
      .assertLogEqual("Host: $host")
      .assertLogEqual("Connection: Keep-Alive")
      .assertLogEqual("Accept-Encoding: gzip")
      .assertLogMatch(Regex("""User-Agent: okhttp/.+"""))
      .assertLogEqual("--> END GET")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Length: 0")

        String actual = null
        wrap({ String payload -> actual = payload }).accept("lajos")
        then:
        actual == "lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ String payload ->
            assert payload == "lajos"
            throw exception
        }).accept("lajos")
    }

        then:
        1 * lockManager.lock(file, _, _, "", _) >> lock

        then:
        1 * initAction.requiresInitialization(lock) >> false

        then:
        1 * onOpenAction.accept(lock)
        0 * _
    }

    def "acquires lock then initializes cache and runs handler action on open"() {
        def lock = Mock(FileLock)

        when:
        cacheAccess.open()

        then:

	if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.AggregatedDiscoveryEndpoint) {
		mediaType, _ := negotiation.NegotiateMediaTypeOptions(req.Header.Get("Accept"), wrapped.s.SupportedMediaTypes(), DiscoveryEndpointRestrictions)
		// mediaType.Convert looks at the request accept headers and is used to control whether the discovery document will be aggregated.
		if IsAggregatedDiscoveryGVK(mediaType.Convert) {
			wrapped.aggHandler.ServeHTTP(resp, req)

                throwError.accept(messages -> fessConfig.invalidIndexRequiredFields(form.doc).stream().map(s -> "doc." + s)
                        .forEach(s -> messages.addErrorsPropertyRequired(s, s)));
            }

            if (!fessConfig.validateIndexArrayFields(form.doc)) {
                throwError.accept(messages -> fessConfig.invalidIndexArrayFields(form.doc).stream().map(s -> "doc." + s)

        _ * target.projectPath >> ":some:path"
        _ * target.rootDir >> rootDir
        _ * buildStateRegistry.visitBuilds(_) >> { Consumer consumer ->
            consumer.accept(buildState1)
            consumer.accept(buildState2)
            consumer.accept(buildState3)
        }
        _ * buildState1.importableBuild >> false
        _ * buildState2.importableBuild >> true

 */
public interface FileSystemLeafSnapshot extends FileSystemLocationSnapshot {
    @Override
    default SnapshotVisitResult accept(FileSystemSnapshotHierarchyVisitor visitor) {
        return visitor.visitEntry(this);
    }

    @Override
    default SnapshotVisitResult accept(RelativePathTracker pathTracker, RelativePathTrackingFileSystemSnapshotHierarchyVisitor visitor) {
        pathTracker.enter(getName());
        try {

        super(selector);
        this.versionParser = versionParser;
    }

    @Override
    public boolean accept(String candidate) {
        return accept(versionParser.transform(candidate));
    }

        this.previous = previous;
        this.current = current;
    }

    @Override
    public boolean accept(ChangeVisitor visitor) {
        return SortedMapDiffUtil.diff(previous, current, new PropertyDiffListener<String, FileSystemSnapshot, FileSystemSnapshot>() {
            @Override