if err != nil {
		return fmt.Errorf("couldn't get node to daemon pod mapping for daemon set %q: %v", ds.Name, err)
	}

	toKeep := int(*ds.Spec.RevisionHistoryLimit)
	toKill := len(old) - toKeep
	if toKill <= 0 {
		return nil
	}

	// Find all hashes of live pods
	liveHashes := make(map[string]bool)
	for _, pods := range nodesToDaemonPods {
		for _, pod := range pods {

                @OutputDirectory
                Path outputDir

                @TaskAction
                def go() {
                    outputFile.toFile().text = inputFile.toFile().text
                    inputDir.toFile().listFiles().each { f -> outputDir.resolve(f.name).toFile().text = f.text }
                }
            }

            task transform(type: TransformTask) {
                inputFile = file("file1.txt").toPath()

                }
            });

            t.transform(project, systemSessionMock, beforePomFile, tempFile);
        }
        XmlAssert.assertThat(afterPomFile.toFile()).and(tempFile.toFile()).areIdentical();
    }

    @Test
    void transformJarConsumerPom() throws Exception {
        RepositorySystemSession systemSessionMock = Mockito.mock(RepositorySystemSession.class);

        final File file = new File("Program Files/hoge.txt");
        final URL url = file.toURI().toURL();
        assertEquals(file.getAbsoluteFile(), URLUtil.toFile(url));
        assertEquals(file.getAbsoluteFile(), URLUtil.toFile(new URL("file:Program%20Files/hoge.txt")));
    }

        if (value instanceof ConfigurableFileTree) {
            return ((ConfigurableFileTree) value).getDir();
        }
        return toFile(context, value);
    }

    private static File toFile(PropertyValidationContext context, Object value) {
        return context.getFileResolver().resolve(value);
    }

    (project as ProjectInternal).services.get<ArchiveOperations>(ArchiveOperations::class.java)

fun findPluginJar(pluginClass: Class<*>) =
    toFile(pluginClass.protectionDomain.codeSource.location)

fun isExternal(pluginClass: Class<*>) =
    !pluginClass.name.startsWith("org.gradle")

fun toFile(url: URL): File? {
    return try {
        File(url.toURI())
    } catch (e: URISyntaxException) {
        null
    }

        NativeServices.initializeOnDaemon(tempRootDir.toFile(), NativeServicesMode.fromSystemProperties());
        this.fileSystem = FileSystems.getDefault();
    }

    @TearDown(Level.Trial)
    public void tearDownTrial() throws IOException {
        FileUtils.forceDelete(tempRootDir.toFile());
    }

    @Setup(Level.Iteration)
    public void setupIteration() throws IOException {

    @Nullable
    public List<String> readLockFile(String lockId) {
        checkValidRoot();

        Path lockFile = lockFilesRoot.resolve(decorate(lockId) + FILE_SUFFIX);
        listener.fileObserved(lockFile.toFile());
        if (Files.exists(lockFile)) {
            List<String> result;
            try {
                result = Files.readAllLines(lockFile, CHARSET);
            } catch (IOException e) {

        @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: