TEST(LegalizeTFTest, DumpsProducedHLO) {
  Env* env = Env::Default();
  std::string test_dir = testing::TmpDir();
  setenv("TF_DUMP_GRAPH_PREFIX", test_dir.c_str(), /*overwrite=*/1);
  setenv("TF_DUMP_GRAPH_NAME_FILTER", "*", 1);
  DEBUG_DATA_DUMPER()->LoadEnvvars();

  std::vector<std::string> files;
  TF_ASSERT_OK(env->GetChildren(test_dir, &files));
  int original_files_size = files.size();

  TF_ASSERT_OK_AND_ASSIGN(

        write(value.delegate)
    }

    override suspend fun ReadContext.decode(): DestinationRootCopySpec {
        val destDir = read() as? File
        val delegate = read() as CopySpecInternal
        val spec = DestinationRootCopySpec(fileResolver, delegate)
        destDir?.let(spec::into)
        return spec
    }

    </target>

    <target name="compile">
        <mkdir dir="\${classes.dir}"/>
        <javac srcdir="\${src.dir}" destdir="\${classes.dir}"/>
    </target>

    <target name="compileTest" depends="compile">
        <mkdir dir="\${test.classes.dir}"/>
        <javac srcdir="\${test.src.dir}" destdir="\${test.classes.dir}">
            <classpath>
                <path location="\${classes.dir}"/>

    private TestFile testDir
    private File downloadedFile
    private URI sourceUri
    private RelativeFilePathResolver resolver = Mock()

    private TextResource underTest

    @Rule
    public TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass());

    def setup() {
        testDir = tmpDir.createDir('dir')

class DefaultCopySpecResolutionTest extends Specification {

    @Rule
    public TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def fileResolver = TestFiles.resolver(testDir.testDirectory)
    def fileCollectionFactory = TestFiles.fileCollectionFactory(testDir.testDirectory)
    def objectFactory = TestUtil.objectFactory()
    def instantiator = TestUtil.instantiatorFactory().decorateLenient()

            def project = projects.empty ? new TestProject("root", this) : new TestProject("project${projects.size()}", this, projects.size())
            projects << project
        }

        ant.delete(dir: destDir)
        destDir.mkdirs()

        gradlebuild.performance.generator.MavenRepository repo = generateDependencyRepository()
        generateRootProject()
        subprojects.each { subproject ->
            if (repo) {

import org.gradle.util.internal.GUtil
import org.junit.Rule
import spock.lang.Specification

class DefaultPluginRegistryTest extends Specification {
    @Rule
    final TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def classLoader = Mock(ClassLoader)
    def classLoaderScope = Stub(ClassLoaderScope) {
        getLocalClassLoader() >> classLoader
    }

import static org.gradle.util.internal.TextUtil.normaliseFileSeparators

class RelativeFileNameTransformerTest extends Specification {
    static rootDir = new File("root")

    @Rule
    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    def "returns canonical path where file outside of root"() {
        expect:
        transform(relative, file) == normaliseFileSeparators(file.canonicalPath)

@pytest.fixture(scope="module")
def client(tmp_path_factory: pytest.TempPathFactory):
    tmp_path = tmp_path_factory.mktemp("data")
    cwd = os.getcwd()
    os.chdir(tmp_path)
    test_db = Path("./sql_app.db")
    if test_db.is_file():  # pragma: nocover
        test_db.unlink()
    # Import while creating the client to create the DB after starting the test session
    from docs_src.sql_databases.sql_app_py39 import alt_main

def get_client(tmp_path_factory: pytest.TempPathFactory):
    tmp_path = tmp_path_factory.mktemp("data")
    cwd = os.getcwd()
    os.chdir(tmp_path)
    test_db = Path("./sql_app.db")
    if test_db.is_file():  # pragma: nocover
        test_db.unlink()
    # Import while creating the client to create the DB after starting the test session
    from docs_src.sql_databases.sql_app_py310 import main