}
    }
  }

  private fun createWorkspace(): Workspace {
    val bndDir = workspaceDir / "cnf"
    val repoDir = bndDir / "repo"
    fileSystem.createDirectories(repoDir)
    return Workspace(workspaceDir.toFile(), bndDir.name)
      .apply {
        setProperty(
          "${Constants.PLUGIN}.$REPO_NAME",
          LocalIndexedRepo::class.java.getName() +
            "; ${LocalIndexedRepo.PROP_NAME} = '$REPO_NAME'" +

import java.nio.file.Path

object DiagnosticClassGenerator {
    fun generate(rootPath: Path, diagnosticList: DiagnosticList, packageName: String) {
        val path = getGenerationPath(rootPath.toFile(), packageName)
        KtDiagnosticClassRenderer.render(path.resolve("KtFirDiagnostics.kt"), diagnosticList, packageName, emptySet())

func (b *Builder) BuildFromAndTo(fromAll echo.Callers, toAll echo.Services) *Builder {
	b.t.Helper()
	out := b.Copy()

	systemNS := istio.ClaimSystemNamespaceOrFail(out.t, out.t)

	for _, from := range fromAll {
		for _, to := range toAll {
			for _, s := range out.needFromAndTo {
				out.addYAML(withParams(s, param.Params{

        @Nullable
        private File jarFileFor(Class<?> pluginClass) {
            return clazzToFile.computeIfAbsent(pluginClass, clazz -> toFile(pluginClass.getProtectionDomain().getCodeSource().getLocation()));
        }

        @Nullable
        private static File toFile(@Nullable URL url) {
            if (url == null) {
                return null;
            }
            try {

        1 * cachedArtifact.cachedAt >> 42L
        1 * cachedArtifact.getDescriptorHash() >> TestHashCodes.hashCodeFrom(42)
        1 * cachedArtifact.getCachedFile() >> commonRootPath.resolve("file.txt").toFile()

        1 * encoder.writeString("file.txt")
    }

    def "value serializer can expand relative path"() {
        given:

        String identity = "test-entity";
        Path targetOutputDirectory = Files.createTempDirectory("target-output");
        ExampleEntity targetEntity = new ExampleEntity(identity, targetOutputDirectory.toFile());

        // Try to load a non-existent entity
        buildCacheController.load(cacheKey, targetEntity)
            .ifPresent(__ -> {
                throw new RuntimeException("Should have been a miss");

    @SuppressWarnings("Since15")
    @Override
    public File canonicalize(File file) throws FileException {
        try {
            return file.toPath().toRealPath().toFile();
        } catch (IOException e) {
            throw new FileException(String.format("Could not canonicalize file %s.", file), e);
        }
    }

            // drive-relative Windows path
            return file.getAbsoluteFile();
        } else {
            return Paths.get(baseDirectory, file.getPath()).normalize().toFile();
        }
    }

        return null;
    }

    @Override
    public boolean canLoad() {
        return false;
    }

    @Override
    public Optional<BuildCacheLoadResult> maybeLoad(BuildCacheKey key, File toFile, Function<File, BuildCacheLoadResult> unpackFunction) {
        return Optional.empty();
    }

    @Override
    public boolean canStore() {
        return false;
    }

    @Override

    def "file conversion works with java.nio.file.Path"() {
        buildFile """
java.nio.file.Path fAsPath = buildDir.toPath().resolve('testdir').toAbsolutePath()
def f = file(fAsPath)
assert f == fAsPath.toFile()
"""

        expect:
        succeeds()
    }

    def "file conversion works with Provider of supported types"() {
        buildFile << """
def provider = project.provider { $expression }