}
                task resolveHash(type: Resolve) {
                    artifacts = configurations.compile.incoming.artifactView {
                        attributes { it.attribute(artifactType, 'hash') }
                    }.artifacts
                    identifier = "2"
                }
                task resolve {
                    dependsOn(resolveHash, resolveSize)
                }
            }

                into "${safePath(ivyRepo.moduleDir('org.gradle.test', 'api'), '1.1')}"
            }
            ${taskWhichResolves('api', '1.1')}
            ${resolveTask}.dependsOn customPublish
        """

        expect:
        succeeds resolveTask
        versionIsCopiedAndExists("api", "1.1")
    }

    def safePath(Object... paths) {
        return TextUtil.escapeString(paths.join(File.separator))
    }

    }

    /**
     * Creates a path relative to the given path variable.
     */
    public FilePath relativePath(String pathVar, File file) {
        return resolvePath(varsByName.get(pathVar), "$" + pathVar + "$", file);
    }

    private static FilePath resolvePath(File rootDir, String rootDirName, File file) {
        String relPath = getRelativePath(rootDir, rootDirName, file);
        String url = relativePathToURI(relPath);

        return includedBuild.getBuildIdentifier();
    }

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        context.add(resolveTask());
    }

    private Task resolveTask() {
        includedBuild.ensureProjectsConfigured();
        return includedBuild.getMutableModel().getRootProject().getTasks().getByPath(taskPath);
    }

        and:
        sizeTransform.waitForAllPendingCalls()
        assertHasBuildPhase("50% EXECUTING")
        sizeTransform.releaseAll()

        and:
        resolveTask.waitForAllPendingCalls()
        assertHasBuildPhase("75% EXECUTING")
        resolveTask.releaseAll()

        and:
        buildFinished.waitForAllPendingCalls()
        assertHasBuildPhase("100% EXECUTING")
        buildFinished.releaseAll()

            return rootBuildState.getBuildIdentifier();
        }

        @Override
        public void visitDependencies(TaskDependencyResolveContext context) {
            context.add(resolveTask());
        }

        private Task resolveTask() {
            rootBuildState.ensureProjectsConfigured();
            return rootBuildState.getMutableModel().getRootProject().getTasks().getByPath(taskPath);
        }
    }

 * limitations under the License.
 */
package org.gradle.api.internal.tasks;

import org.gradle.api.Task;

public interface TaskResolver {
    Task resolveTask(String path);

            file("src/main/java/ResolveTask.java") << """
                import ${DefaultTask.name};
                import ${ConfigurableFileCollection.name};
                import ${InputFiles.name};
                import ${PathSensitive.name};
                import ${PathSensitivity.name};
                import ${TaskAction.name};

                public abstract class ResolveTask extends DefaultTask {

               extendsFrom(configurations.$configuration)
            }
            tasks.register('resolvePath') {
              def path = configurations.path
              doLast { println(path.collect { it.name }) }
            }
        """

        when:
        succeeds 'resolvePath'

        then:
        outputContains('[a-1.0.jar]')

        where:
        configuration          | _

        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(
                "deserialize",
                Task::class,
                documentationSection = RequirementsTaskAccess