private void moveFile(File targetFile, File downloadFile) throws IOException {
        try {
            Files.move(downloadFile.toPath(), targetFile.toPath(), StandardCopyOption.ATOMIC_MOVE);
        } catch (AtomicMoveNotSupportedException e) {
            Files.move(downloadFile.toPath(), targetFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        }
    }

            switch (diff) {
                case FILE: {
                    Path expectedFile = buildDir.relativize(expected.getFile().toPath());
                    Path actualFile = buildDir.relativize(actual.getFile().toPath());
                    return "\t- file differs (relative to " + projectDisplayName + "): (expected) " + expectedFile + " != (actual) " + actualFile;
                }

		})
	}
	oldcheckpoint := &DRAManagerCheckpointWithoutResourceHandles{
		Version:  checkpointVersion,
		Entries:  entries,
		Checksum: 0,
	}
	// Calculate checksum for old checkpoint
	object := dump.ForHash(oldcheckpoint)
	object = strings.Replace(object, "DRAManagerCheckpointWithoutResourceHandles", "DRAManagerCheckpoint", 1)
	object = strings.Replace(object, "ClaimInfoStateListWithoutResourceHandles", "ClaimInfoStateList", 1)

     * The IDE distribution is automatically downloaded if required.
     */
    protected void ideaSync(String version) {
        def gradleDist = distribution.gradleHomeDir.toPath()
        def ide = "ic-$version"
        runIdeStarterWith(gradleDist, testDirectory.toPath(), ideHome, ide)
    }

    protected TestFile getTestDirectory() {
        temporaryFolder.testDirectory
    }

    protected TestFile file(Object... path) {

        // here and be safe. jvz.
        // ----------------------------------------------------------------------------

        try {
            Files.createDirectories(destination.toPath().getParent());
            Files.copy(file.toPath(), destination.toPath());
        } catch (IOException e) {
            throw new RepositoryMetadataStoreException("Error copying POM to the local repository.", e);
        }
    }

import okio.Path
import okio.Path.Companion.toPath
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

@Tag("Slow")
class OsgiTest {
  private lateinit var testResourceDir: Path
  private lateinit var workspaceDir: Path

  @BeforeEach
  fun setUp() {
    testResourceDir = "./build/resources/test/okhttp3/osgi".toPath()
    workspaceDir = testResourceDir / "workspace"

	// Do the file I/O before acquiring the go.sum lock.
	ziphash, err := CachePath(ctx, mod, "ziphash")
	if err != nil {
		base.Fatalf("verifying %v", module.VersionError(mod, err))
	}
	data, err := lockedfile.Read(ziphash)
	if err != nil {
		base.Fatalf("verifying %v", module.VersionError(mod, err))
	}
	data = bytes.TrimSpace(data)
	if !isValidSum(data) {
		// Recreate ziphash file from zip file and use that to check the mod sum.

}

func sourceDir(file string) string {
	dir := filepath.Dir(file)
	dir = filepath.Dir(dir)

	s := filepath.Dir(dir)
	if filepath.Base(s) != "gorm.io" {
		s = dir
	}
	return filepath.ToSlash(s) + "/"
}

// FileWithLineNum return the file name and line number of the current file
func FileWithLineNum() string {
	pcs := [13]uintptr{}
	// the third caller usually from gorm internal

                        println("Transforming \${input.name} to \${input.name}.\${target}")
                    }
                    Files.copy(input.toPath(), output1.toPath())
                    Files.copy(input.toPath(), output2.toPath())
                }
            }

            abstract class GreenMultiplier extends Multiplier {
                GreenMultiplier() {
                    super("green")

            }
        });
        unchecked(() -> Files.write(target.toPath(), resultFileContents));
    }

    public TransformExecutionResult readResultsFile(File resultsFile) {
        Path transformerResultsPath = resultsFile.toPath();
        try {
            TransformExecutionResult.Builder builder = TransformExecutionResult.builder();