* Creates the fixture.
     */
    JarTestFixture(File file, String metadataCharset, String contentCharset, boolean checkManifest) {
         super(file, metadataCharset, contentCharset)
         this.file = file
         if (checkManifest) {
             assertManifestPresentAndFirstEntry()
         }
     }

    /**
     * Asserts that the given service is defined in this jar file.
     */

    assert response.status_code == 200, response.text
    assert response.json() == {"file_size": 14}


@needs_py39
def test_post_large_file(tmp_path, client: TestClient):
    default_pydantic_max_size = 2**16
    path = tmp_path / "test.txt"
    path.write_bytes(b"x" * (default_pydantic_max_size + 1))

    with path.open("rb") as file:
        response = client.post("/files/", files={"file": file})

 */
package org.gradle.api.internal.file;

import com.google.common.collect.ImmutableSet;
import groovy.lang.Closure;
import org.gradle.api.file.DirectoryTree;
import org.gradle.api.file.FileCollection;
import org.gradle.api.file.FileSystemLocation;
import org.gradle.api.file.FileVisitDetails;
import org.gradle.api.file.FileVisitor;
import org.gradle.api.internal.file.collections.DirectoryFileTree;

        given:
        multiProjectJavaBuild("subproject") {
            file("$it/impl/src/main/java/A.java") << "public class A extends B {}"
            file("$it/api/src/main/java/B.java") << "public class B extends C {}"
            file("$it/api/src/main/java/C.java") << "import org.gradle.D; public class C extends D {}"
            file("$it/api/src/main/java/org/gradle/D.java") << "package org.gradle; public class D extends E {}"

    def "#desc can handle symlinks"() {
        def buildScript = file("build.gradle")
        def baseDir = file('build')
        baseDir.file('file').text = 'some contents'
        def symlinked = baseDir.file('symlinked')
        symlinked.text = 'target of symlink'
        baseDir.file('symlink').createLink(symlinked)

        buildScript << """
            def baseDir = new File("${escapeString(baseDir)}")

            [fromObjectList(), "ProcessGroovyMethods.execute(command, new String[] {'FOOBAR=foobar'}, file('$pwd'))", pwd, "foobar"],
            [fromString(), "ProcessGroovyMethods.execute(command, ['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],
            [fromGroovyString(), "ProcessGroovyMethods.execute(command, ['FOOBAR=foobar'], file('$pwd'))", pwd, "foobar"],

    def "delete task removes specified files"() {
        file('foo') << "foo"
        file('bar') << "bar"
        file('baz') << "baz"

        buildFile << """
            assert file('foo').exists()
            assert file('bar').exists()
            assert file('baz').exists()

            task clean(type: Delete) {
                delete 'foo'
                delete file('bar')
                delete files('baz')
             }

        def classpath = underTest.create([
            new File("app-cls-1.0.jar"), new File("app-mod-1.0.jar"), new File("impl-cls-1.0.jar"), new File("impl-mod-1.0.jar")
        ], [], framework, true)

        then:
        classpath.applicationClasspath == [new File("app-cls-1.0.jar"), new File("app-mod-1.0.jar"), new File("impl-cls-1.0.jar"), new File("impl-mod-1.0.jar")]
        classpath.applicationModulepath.isEmpty()

        else file

    private
    fun maybeRelativize(file: File): File =
        if (!file.isAbsolute) file else File(GFileUtils.relativePathOf(file, rootDirectory))

    private
    fun wildcardsToRegexPatternString(pathWithWildcards: String): String {
        fun String.runIfNotEmpty(action: String.() -> String): String =
            if (this.isEmpty()) this else action()

import org.gradle.util.GradleVersion;

import java.io.File;

@ServiceScope(Scope.Global.class)
public class DaemonDir {
    private final File baseDir;
    private final File versionedDir;
    private final File registryFile;

    public DaemonDir(File baseDir) {
        this.baseDir = baseDir;
        this.versionedDir = new File(baseDir, GradleVersion.current().getVersion());