* 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"

}

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();

import java.io.File
import okio.FileSystem
import okio.Path.Companion.toPath

fun main(vararg args: String) {
  val data = loadIdnaMappingTableData()
  val file = generateMappingTableFile(data)
  file.writeTo(File(args[0]))
}

fun loadIdnaMappingTableData(): IdnaMappingTableData {
  val path = "/okhttp3/internal/idna/IdnaMappingTable.txt".toPath()
  val table =
    FileSystem.RESOURCES.read(path) {

    }

    public void merge(File current, File result) throws RepositoryException {
        try {
            if (current.exists()) {
                Files.createDirectories(result.toPath().getParent());
                Files.copy(current.toPath(), result.toPath());
            }
            ArtifactRepository localRepo = new MetadataRepository(result);
            metadata.storeInLocalRepository(localRepo, localRepo);
            merged = true;

        def copy = file("other")

        given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:
        Files.move(inDir.toPath(), copy.toPath(), StandardCopyOption.ATOMIC_MOVE)
        inDir.deleteDir()
        inDir.createLink(copy)

        run("work")

        /*
         * This documents the current behavior, which is optimizing

                public abstract RegularFileProperty getOutFile();

                @TaskAction
                public void run() throws IOException {
                    Files.write(getOutFile().get().getAsFile().toPath(), "content".getBytes());
                }
            }
        """

    }

    @Override
    void taskWithNestedBeanDefinition() {
        pluginDir.file("src/main/java/ProducerTask.java") << """