Filenames: &filenames,
			Recursive: boolPtr(true),
		},
	}
}

// WithFile sets the FileNameFlags.
// If recurse is set, it will process directory recursively. Useful when you want to manage related manifests
// organized within the same directory.
func (o *ResourceBuilderFlags) WithFile(recurse bool, files ...string) *ResourceBuilderFlags {
	o.FileNameFlags = &FileNameFlags{

        if (ruleClass == TestSupplierWithService) {
            ruleServices['SomeService'] = someService
        }
        def reexecute = mustRefresh || expired

        when:
        withRule(ruleClass, ruleServices)
        execute(id)

        then:
        1 * valueSnapshotter.snapshot(_) >> inputsSnapshot
        1 * store.getIfPresent(keyHash) >> cachedEntry
        if (expired) {

    }

    private
    fun withPrecompiledScriptPluginInBuildSrc(pluginId: String, pluginSource: String) {
        withKotlinDslPluginInBuildSrc()
        withFile("buildSrc/src/main/kotlin/$pluginId.gradle.kts", pluginSource)
    }

		firstIdentifier := n.(*parse.FieldNode).Ident[0]
		out.Insert(firstIdentifier)
	case parse.NodeIf:
		out.Merge(getParams(n.(*parse.IfNode).Pipe))
	case parse.NodeWith:
		out.Merge(getParams(n.(*parse.WithNode).Pipe))
	case parse.NodeRange:
		out.Merge(getParams(n.(*parse.RangeNode).Pipe))
	case parse.NodeAction:
		out.Merge(getParams(n.(*parse.ActionNode).Pipe))
	case parse.NodeCommand:

        def reexecute = mustRefresh || expired
        def moduleSources = new MutableModuleSources()
        moduleSources.add(new ModuleDescriptorHashModuleSource(hashValue, false))

        when:
        withRule(ruleClass, ruleServices)
        execute(key)

        then:
        1 * key.getSources() >> moduleSources
        1 * key.getVariantDerivationStrategy() >> Stub(VariantDerivationStrategy)

            }
            $repositoriesBlock
            $compileKotlinTaskConfiguration
            """
        )
    }

    private
    fun withKotlinSourceFile() {
        withFile(
            "src/main/kotlin/my/Foo.kt",
            """
            package my

            class Foo(val bar: String)
            """
        )
    }

    }

    def "jit accessors can be turned off"() {

        given:
        withDefaultSettings()
        withBuildScript("""
            plugins { java }
        """)

        and:
        withFile("gradle.properties", "org.gradle.kotlin.dsl.accessors=off")

        expect:
        assertThat(
            classPathFor(projectDir, buildFile),
            not(hasAccessorsClasses())
        )
    }

     *
     * The version for the hierarchy is the maximum version of all the locations in the hierarchy.
     */
    public long getVersion(VfsRelativePath relativePath, CaseSensitivity caseSensitivity) {
        return children.withNode(relativePath, caseSensitivity, new ChildMap.NodeHandler<VersionHierarchy, Long>() {
            @Override
            public Long handleAsDescendantOfChild(VfsRelativePath pathInChild, VersionHierarchy child) {

			ip = netip.AddrFrom4(from.Addr)
			port = from.Port
		}
	case syscall.AF_INET6:
		var from syscall.SockaddrInet6
		n, err = c.fd.readFromInet6(b, &from)
		if err == nil {
			ip = netip.AddrFrom16(from.Addr).WithZone(zoneCache.name(int(from.ZoneId)))
			port = from.Port
		}
	}
	if err == nil {
		addr = netip.AddrPortFrom(ip, uint16(port))
	}
	return n, addr, err
}

}

// WithNode represents a {{with}} action and its commands.
type WithNode struct {
	BranchNode
}

func (t *Tree) newWith(pos Pos, line int, pipe *PipeNode, list, elseList *ListNode) *WithNode {
	return &WithNode{BranchNode{tr: t, NodeType: NodeWith, Pos: pos, Line: line, Pipe: pipe, List: list, ElseList: elseList}}
}

func (w *WithNode) Copy() Node {