func PutBytes(c Cache, id ActionID, data []byte) error {
	_, _, err := c.Put(id, bytes.NewReader(data))
	return err
}

// copyFile copies file into the cache, expecting it to have the given
// output ID and size, if that file is not present already.
func (c *DiskCache) copyFile(file io.ReadSeeker, out OutputID, size int64) error {
	name := c.fileName(out, "d")
	info, err := os.Stat(name)

     * @param dest
     * @param b
     * @param bsize
     * @param w
     * @param dh
     * @param sh
     * @param req
     * @param resp
     * @throws SmbException
     */
    static void copyFile ( SmbFile src, SmbFile dest, byte[][] b, int bsize, WriterThread w, SmbTreeHandleImpl sh, SmbTreeHandleImpl dh )
            throws SmbException {

        if ( sh.isSMB2() && dh.isSMB2() && sh.isSameTree(dh) ) {

	// Copy binaries into tool binary directory.
	for _, name := range bootstrapDirs {
		if !strings.HasPrefix(name, "cmd/") {
			continue
		}
		name = name[len("cmd/"):]
		if !strings.Contains(name, "/") {
			copyfile(pathf("%s/%s%s", tooldir, name, exe), pathf("%s/bin/%s%s", workspace, name, exe), writeExec)
		}
	}

	if vflag > 0 {
		xprintf("\n")
	}
}

	dest := filepath.Join(backupDir, kubeadmconstants.KubeletConfigurationFileName)

	if !dryRun {
		fmt.Printf("[upgrade] Backing up kubelet config file to %s\n", dest)
		err := kubeadmutil.CopyFile(src, dest)
		if err != nil {
			return errors.Wrap(err, "error backing up the kubelet config file")
		}
	} else {
		fmt.Printf("[dryrun] Would back up kubelet config file to %s\n", dest)
	}

                    inputFiles.files.each { File inputFile ->
                        def outputFile = buildDirectory.file(inputFile.name + ".out").get().asFile
                        GFileUtils.copyFile(inputFile, outputFile)
                    }
                }
            }
            allprojects {
                apply plugin: 'java-library'

  ops->filesystem_ops->delete_dir = tf_gcs_filesystem::DeleteDir;
  ops->filesystem_ops->delete_recursively =
      tf_gcs_filesystem::DeleteRecursively;
  ops->filesystem_ops->copy_file = tf_gcs_filesystem::CopyFile;
  ops->filesystem_ops->path_exists = tf_gcs_filesystem::PathExists;
  ops->filesystem_ops->is_directory = tf_gcs_filesystem::IsDirectory;
  ops->filesystem_ops->stat = tf_gcs_filesystem::Stat;

                     persistor.device_type(), persistor.persistence_prefix());
  // File for key2 contains the same content as key1.
  TF_ASSERT_OK(Env::Default()->CopyFile(
      GetFilePath(key1, persistor.persistent_cache_directory()),
      GetFilePath(key2, persistor.persistent_cache_directory())));

  MockXlaCompilerClient mock_client;

        file("jars/first").mkdirs()
        file("jars/second").mkdirs()
        def jar = file("jars/first/test-plugin-0.2.jar").with {
            it.createFile()
        }
        GFileUtils.copyFile(jar, file("jars/second/test-plugin-0.2.jar"))

        when:
        buildFile.text = """
            buildscript {
                dependencies {

		arArgs = []string{"-X64"}
	}

	newID := 0
	readAndRemoveCgoFlags := func(archive string) (string, error) {
		newID++
		newArchive := root.Objdir + fmt.Sprintf("_pkg%d_.a", newID)
		if err := sh.CopyFile(newArchive, archive, 0666, false); err != nil {
			return "", err
		}
		if cfg.BuildN || cfg.BuildX {
			sh.ShowCmd("", "ar d %s _cgo_flags", newArchive)
			if cfg.BuildN {

            }
            subdir2 {
                file('file2.txt').text = 'original text 2'
                file('file3.txt').text = 'original text 3'
            }
        }
        FileUtils.copyFile(file('test1.tar'), file('test2.tar'));

        and: "where a build edits each archive differently via a visitor"
        file('build.gradle') << """
            ${defineUpdateTask('tar')}