return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {
        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override

        }
        return toProjection();
    }

    public ModelAdapter getAdapter() {
        if (!state.isAtLeast(State.Created)) {
            throw new IllegalStateException(String.format("Cannot get adapter for '%s' in state %s.", getPath(), state));
        }
        return toProjection();
    }

    RateLimiter limiter = RateLimiter.create(5.0, 5, SECONDS);
    assertEquals(5.0, limiter.getRate());
    limiter.setRate(10.0);
    assertEquals(10.0, limiter.getRate());

    assertThrows(IllegalArgumentException.class, () -> limiter.setRate(0.0));
    assertThrows(IllegalArgumentException.class, () -> limiter.setRate(-10.0));
  }

  public void testAcquireParameterValidation() {
    RateLimiter limiter = RateLimiter.create(999);

    RateLimiter limiter = RateLimiter.create(5.0, 5, SECONDS);
    assertEquals(5.0, limiter.getRate());
    limiter.setRate(10.0);
    assertEquals(10.0, limiter.getRate());

    assertThrows(IllegalArgumentException.class, () -> limiter.setRate(0.0));
    assertThrows(IllegalArgumentException.class, () -> limiter.setRate(-10.0));
  }

  public void testAcquireParameterValidation() {
    RateLimiter limiter = RateLimiter.create(999);

    }

    static <T> ChildMap<T> childMap(CaseSensitivity caseSensitivity, ChildMap.Entry<T> entry1, ChildMap.Entry<T> entry2) {
        int compared = PathUtil.getPathComparator(caseSensitivity).compare(entry1.getPath(), entry2.getPath());
        List<ChildMap.Entry<T>> sortedEntries = compared < 0
            ? ImmutableList.of(entry1, entry2)
            : ImmutableList.of(entry2, entry1);
        return childMapFromSorted(sortedEntries);
    }

            } else if (output.getPath().startsWith(outputDirPrefix)) {
                String relativePath = RelativePath.parse(true, output.getPath().substring(outputDirPrefix.length())).getPathString();
                delegate.addProducedOutput(relativePath);
                workspaceAction.accept(output);
            } else if (output.getPath().startsWith(inputArtifactPrefix)) {

        lock.lock();
        try {
            return started;
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String getPath() {
        return handler.getPath();
    }

    @Override
    public String getMethod() {
        return handler.getMethod();
    }

    @Override
    public void assertCanWait() throws IllegalStateException {

        long now = clock.getCurrentTime();
        buildProfile.getProjectProfile(project.getPath()).getConfigurationOperation().setStart(now);
    }

    @Override
    public void afterEvaluate(Project project, ProjectState state) {
        long now = clock.getCurrentTime();
        ProjectProfile projectProfile = buildProfile.getProjectProfile(project.getPath());
        projectProfile.getConfigurationOperation().setFinish(now);
    }

        return origin;
    }

    /**
     * A string representing the path of this {@link ClassLoaderScope} in the {@link ClassLoaderScope} graph.
     */
    public String getPath() {
        return id.getPath();
    }

    @Override
    public ClassLoaderScope local(ClassPath classPath) {
        return immutable();
    }

    @Override
    public ClassLoaderScope export(ClassPath classPath) {

     * Called for each root of the current property.
     * <p>
     * {@link VisitState#getName()} and {@link VisitState#getPath()} may be called during.
     */
    void preRoot(VisitState state);

    /**
     * Called before entering a directory.
     * <p>
     * {@link VisitState#getName()} and {@link VisitState#getPath()} may be called during.
     */
    void preDirectory(VisitState state);

    /**