/**
   * @throws IllegalStateException if the directory could not be created (to implement the contract
   *     of {@link Files#createTempDir()}, such as if the system does not support creating temporary
   *     directories securely
   */
  abstract File createTempDir();

  abstract File createTempFile(String prefix) throws IOException;

  private static TempFileCreator pickSecureCreator() {
    try {

#include "tsl/platform/status_matchers.h"

namespace tensorflow {
namespace {

using ::stablehlo::quantization::QuantizationConfig;
using ::stablehlo::quantization::io::CreateTmpDir;
using ::testing::HasSubstr;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

// Test cases for `RunQuantization` mainly tests for error cases because testing

  absl::StatusOr<std::string> tmp_dir = CreateTmpDir();

  ASSERT_THAT(tmp_dir, IsOk());

  auto* const env = tsl::Env::Default();
  EXPECT_THAT(env->FileExists(*tmp_dir), IsOk());
}

TEST(IoTest, CreateTmpDirWhenInvalidPathReturnsInternalError) {
  TestEnvBrokenFileSystem test_env{};
  absl::StatusOr<std::string> tmp_dir = CreateTmpDir(&test_env);

}

absl::StatusOr<std::string> CreateTmpDir(tsl::Env* const env) {
  TF_ASSIGN_OR_RETURN(std::string tmp_dir, GetLocalTmpFileName(env));

  if (!env->RecursivelyCreateDir(tmp_dir).ok()) {
    return absl::InternalError(
        absl::StrFormat("Failed to create tmp dir: '%s'", tmp_dir));
  }

  return tmp_dir;
}

absl::StatusOr<std::string> CreateTmpDir() {
  // The overloaded function uses the default env.

      }
    }

    if (testDir == null) {
      // testdata resources aren't file:// urls, so create a directory to store them in and then
      // copy the resources to the filesystem as needed
      testDir = createTempDir();
    }

    return testDir;
  }

  /** Returns the file with the given name under the testdata directory. */
  protected final @Nullable File getTestFile(String name) throws IOException {

            .because(RATIONALE);

    @ArchTest
    public static final ArchRule forbid_calls_to_guava_Files_createTempDir =
        classes()
            .should(not(callMethod(com.google.common.io.Files.class, "createTempDir")))
            .because(RATIONALE);

    @ArchTest
    public static final ArchRule forbid_illegal_calls_to_File_createTempFile_overload =
        classes()

        }
    }

    public void markForDeletion(File toDelete) {
        filesToDelete.add(toDelete);
        warnAboutCleanup = true;
    }

    public synchronized File createTempDir() {
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            // ignore
        }

        File dir = new File(TEMP_DIR_PATH, baseFilename + System.currentTimeMillis());

// failed.
absl::StatusOr<std::string> CreateTmpDir(tsl::Env* env);

// Creates a temporary directory and returns its path. Returns an InternalError
// status if failed. The file system used will be the default environment
// returned by `tsl::Env::Default`.
absl::StatusOr<std::string> CreateTmpDir();

// Convenience function for writing string `data` to file without the need to

  TF_ASSIGN_OR_RETURN(const std::string calibration_saved_model_dir,
                      CreateTmpDir());

  std::string calibration_data_dir =
      config.calibration_options().calibration_data_dir();
  if (calibration_data_dir.empty()) {
    TF_ASSIGN_OR_RETURN(calibration_data_dir, CreateTmpDir());
  }

  TF_RETURN_IF_ERROR(ExportToSavedModel(
      module_op, calibration_data_dir,

 *
 * @author Jens Nyman
 */

public class FilesFileTraverserTest extends IoTestCase {

  private File rootDir;

  @Override
  public void setUp() throws IOException {
    rootDir = createTempDir();
  }

  public void testFileTraverser_emptyDirectory() throws Exception {
    assertThat(Files.fileTraverser().breadthFirst(rootDir)).containsExactly(rootDir);
  }