return err
	}
	entries, err := os.ReadDir(src)
	if err != nil {
		return err
	}
	for _, entry := range entries {
		err = copyFile(filepath.Join(dst, entry.Name()), filepath.Join(src, entry.Name()))
		if err != nil {
			return err
		}
	}
	return nil
}

func copyFile(dst, src string) (err error) {
	var s, d *os.File
	s, err = os.Open(src)
	if err != nil {
		return err
	}
	defer s.Close()

                            file.text = originalContent
                        } else {
                            originalContent = file.text
                            FileUtils.copyFile(file, backupFile)
                        }
                        originalContentFor = file
                    }
                    if (context.iteration % 2 == 0) {
                        println "Changing $file"

void Stat(const TF_Filesystem* filesystem, const char* path,
          TF_FileStatistics* stats, TF_Status* status);
void DeleteDir(const TF_Filesystem* filesystem, const char* path,
               TF_Status* status);
void CopyFile(const TF_Filesystem* filesystem, const char* src, const char* dst,
              TF_Status* status);
void RenameFile(const TF_Filesystem* filesystem, const char* src,
                const char* dst, TF_Status* status);

                    builder(archiveContentsDir.usingNativeTools(), archive)
                }
                File target = new File(invocationSettings.projectDir, name)
                FileUtils.copyFile(archive, target)
            }
        }
    }

    private static BuildMutator linkToArchiveContents(InvocationSettings invocationSettings, File source) {
        new BuildMutator() {
            @Override

                || f.name.contains("gradle-tooling-api")
                || f.name.contains("gradle-core")
                || f.name.contains("gradle-build-process-services")
            ) {
                GFileUtils.copyFile(f, new File(jarsDir, f.name))
            }
        }

        def testKitJar = jarsDir.listFiles().find { it.name.contains "test-kit" }
        buildFile << """
            dependencies {

			// If using an external CA while dryrun, copy kubeconfig files to dryrun dir for later use
			if data.DryRun() {
				err := kubeadmutil.CopyFile(filepath.Join(kubeadmconstants.KubernetesDir, kubeConfigFileName), filepath.Join(data.KubeConfigDir(), kubeConfigFileName))
				if err != nil {

            File copyOfOriginalFile = outputs.file(ORIGINAL_DIR_NAME + "/" + input.getName());
            GFileUtils.copyFile(input, copyOfOriginalFile);
        }
    }

    protected abstract InterceptorTypeRegistryAndFilter provideInterceptorTypeRegistryAndFilter();

    protected interface InterceptorTypeRegistryAndFilter {

                     uint64* file_size) override;
  Status RenameFile(const std::string& src, const std::string& target,
                    TransactionToken* token) override;
  Status CopyFile(const std::string& src, const std::string& target,
                  TransactionToken* token) override;
  std::string TranslateName(const std::string& name) const override;
  void FlushCaches(TransactionToken* token) override;

executable: gradle
args: copyFiles -q
expected-output-file: copyFiles.out

executable: gradle
args: copyFiles -q
expected-output-file: copyFiles.out