File remoteFile = new File(basedir, path(download.getArtifact()));
                try {
                    Path dest = download.getPath();
                    Files.createDirectories(dest.getParent());
                    Files.copy(remoteFile.toPath(), dest);
                } catch (IOException e) {
                    if (!remoteFile.exists()) {

    def "downloads file"() {
        given:
        def destination = tmpDir.file('destinationDir/file')
        def remoteFile = tmpDir.file('remoteFile') << 'sometext'
        def sourceUrl = remoteFile.toURI()

        when:
        def download = new Download(new Logger(true), "gradlew", "aVersion")
        download.download(sourceUrl, destination)

        then:

            }

            ArtifactRepository remoteRepo = request.getRemoteRepositories().get(0);

            File remoteFile = new File(remoteRepo.getBasedir(), remoteRepo.pathOf(artifact));

            Files.createDirectories(localFile.toPath().getParent());
            Files.copy(remoteFile.toPath(), localFile.toPath());
        }

        artifact.setResolved(true);
    }

    public void retrieve(

      if (($Attempts -ne 0) -And ($currentAttempt -Gt 5)) {
        throw "Attempted to download ${url} ${currentAttempt} times. Giving up."
      }
      $currentAttempt++
      try {
        Get-RemoteFile -OutFile $OutFile -Url $url -Headers $Headers
      }
      catch {
        $message = $_.Exception.ToString()
        Log-Output "Failed to download file from ${Url}. Will retry. Error: ${message}"
        continue

			removeFile(filepath.Join(p.Dir, name))
		}
	}

	if cleanI && p.Target != "" {
		if cfg.BuildN || cfg.BuildX {
			sh.ShowCmd("", "rm -f %s", p.Target)
		}
		if !cfg.BuildN {
			removeFile(p.Target)
		}
	}

	if cleanR {
		for _, p1 := range p.Internal.Imports {
			clean(p1)
		}
	}
}

import java.util.Set;

public interface MutableComponentVariant {

    String getName();

    List<? extends ComponentVariant.File> getFiles();

    void addFile(String name, String uri);

    boolean removeFile(ComponentVariant.File file);

    List<ComponentVariant.Dependency> getDependencies();

                    }
                }
                if (invalidFiles != null) {
                    for (ComponentVariant.File invalidFile : invalidFiles) {
                        mutableVariant.removeFile(invalidFile);
                        mutableVariant.addFile(invalidFile.getName(), invalidFile.getUri().replace("SNAPSHOT", uniqueIdentifier.getTimestamp()));
                    }
                }
            }
        }

	checkPos(apos3, "fileA:1:4")
	checkPos(bpos3, "fileB:1:4")
	checkNumFiles(2)

	// After removal, queries on fileA fail.
	fset.RemoveFile(a)
	checkPos(apos3, "-")
	checkPos(bpos3, "fileB:1:4")
	checkNumFiles(1)

	// idempotent / no effect
	fset.RemoveFile(a)
	checkPos(apos3, "-")
	checkPos(bpos3, "fileB:1:4")
	checkNumFiles(1)
}

func TestFileAddLineColumnInfo(t *testing.T) {
	const (

  // used to satisfy the read.
  env->SetNowSeconds(365 * 24 * 60 * 60);  // ~1 year, just for fun.
  TF_EXPECT_OK(ReadCache(&cache2, "", 0, 1, &out));
  EXPECT_EQ(calls, 1);
}

TEST(RamFileBlockCacheTest, RemoveFile) {
  int calls = 0;
  auto fetcher = [&calls](const string& filename, size_t offset, size_t n,
                          char* buffer, TF_Status* status) -> int64_t {
    calls++;

  }
}

void RamFileBlockCache::Flush() {
  absl::MutexLock lock(&mu_);
  block_map_.clear();
  lru_list_.clear();
  lra_list_.clear();
  cache_size_ = 0;
}

void RamFileBlockCache::RemoveFile(const std::string& filename) {
  absl::MutexLock lock(&mu_);
  RemoveFile_Locked(filename);
}

void RamFileBlockCache::RemoveFile_Locked(const std::string& filename) {
  Key begin = std::make_pair(filename, 0);