}
    }

    @Override
    public Optional<byte[]> getBytes(URI relativeSource) {
        try {
            Path tempPath = null;
            try {
                tempPath = Files.createTempFile("transport-get", "tmp");
                if (get(relativeSource, tempPath)) {
                    // TODO: check file size and prevent OOM?
                    return Optional.of(Files.readAllBytes(tempPath));

        dir.mkdirs();
        markForDeletion(dir);

        return dir;
    }

    public synchronized File createTempFile() throws IOException {
        File tempFile = File.createTempFile(baseFilename, fileSuffix);
        tempFile.deleteOnExit();
        markForDeletion(tempFile);

        return tempFile;
    }

    public void cleanUp() throws IOException {

              }
              Files.deleteIfExists(dir);
              return FileVisitResult.CONTINUE;
            }
          });
    }
  }

  private Path createTempFile() throws IOException {
    return Files.createTempFile(tempDir, "test", ".test");
  }

  public void testByteSource_size_ofDirectory() throws IOException {
    try (FileSystem fs = Jimfs.newFileSystem(Configuration.unix())) {

    @Override
    public void setUp() throws Exception {
        super.setUp();
        final File propFile = File.createTempFile("project", ".properties");
        propFile.deleteOnExit();
        FileUtil.writeBytes(propFile.getAbsolutePath(), "fess.version=98.76.5".getBytes());
        final File desginJspRootFile = File.createTempFile("jsp", "");
        desginJspRootFile.delete();
        desginJspRootFile.deleteOnExit();

            if (buildDir != null) {
                Files.createDirectories(buildDir);
            }
            Path consumer = buildDir != null
                    ? Files.createTempFile(buildDir, CONSUMER_POM_CLASSIFIER + "-", ".pom")
                    : Files.createTempFile(CONSUMER_POM_CLASSIFIER + "-", ".pom");
            deferDeleteFile(consumer);

            project.addAttachedArtifact(createConsumerPomArtifact(project, consumer, session));

        Path afterPomFile =
                Paths.get("src/test/resources/projects/transform/after.pom").toAbsolutePath();
        Path tempFile = Files.createTempFile("", ".pom");
        Files.delete(tempFile);
        try (InputStream expected = Files.newInputStream(beforePomFile)) {
            Model model = new Model(new MavenStaxReader().read(expected));

public class DictionaryManagerTest extends UnitFessTestCase {
    private File testDir;

    private File file1;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        testDir = File.createTempFile("synonymtest", "_dir");
        testDir.delete();
        testDir.mkdirs();
        file1 = new File(testDir, "synonym.txt");

        HtmlTagBasedGenerator generator = new HtmlTagBasedGenerator();
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        File outputFile = File.createTempFile("generator_", ".png");

        String imagePath = "thumbnail/600x400.png";
        try (ImageInputStream input = ImageIO.createImageInputStream(classLoader.getResourceAsStream(imagePath))) {

        1 * action.execute(value2)
        0 * action._
    }

    def canPersistMetaData() {
        TestDomainObject value = new TestDomainObject('a')
        File file = Files.createTempFile(tmpDir.toPath(), null, null).toFile()
        repository.put('class', value)

        when:
        repository.store(file)
        def newRepo = new SimpleClassMetaDataRepository<TestDomainObject>()

            @Override
            public Integer getLdapMaxUsernameLengthAsInteger() {
                return Integer.valueOf(-1);
            }
        };
        File file = File.createTempFile("test", ".properties");
        file.deleteOnExit();
        FileUtil.writeBytes(file.getAbsolutePath(), "ldap.security.principal=******@****.***".getBytes("UTF-8"));