try {
            deleteDir();
        } catch (RuntimeException e) {
            // Ignore
        }
        return this;
    }

    /**
     * Recursively delete this directory, reporting all failed paths.
     */
    public TestFile forceDeleteDir() throws IOException {
        if (isDirectory()) {
            if (FileUtils.isSymlink(this)) {
                if (!delete()) {

        1 * buildOperationRunner.call(_)
    }

    def "build worker operation is finished even if worker fails"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> client
        1 * buildOperationRunner.call(_) >> { args -> args[0].call() }

 * </ul>
 * </p>
 *
 * <p>
 * There are {@code call(...)} equivalents for all the {@code add(...)} and {@code addConstraint(...)} methods in {@link DependencyCollector}.
 * </p>
 *
 * <p>
 * There are {@code call(...)} equivalents for all the {@code modify(...)} methods in {@link DependencyModifier}.
 * </p>
 *
 * @see Dependencies
 * @see DependencyCollector

        String methodName = call.getMethodAsString();
        if (call.isImplicitThis() && methodName != null && methodName.equals(DOLLAR)) {
            visitInputMethod(call);
            return;
        }
        // visit the method call, because one of the args may be an input method call
        super.visitMethodCallExpression(call);
    }

         *
         * Because of it doing so, our decorated call site is removed from the dynamic invocation code path, and we lose the ability to track dynamic call entry points. <p>
         *
         * To fix that, we store the optimized call site that the Groovy runtime created (and we delegate to it in subsequent calls), and we put a reference to our
         * decorated call site back into the call site array.
         */

         * MetaClass.getMetaProperty(name) is very expensive when the property is not known.
         * Instead, we reach into the meta class to call a much more efficient lookup method.
         * Since we do this in a hot code path, we also reuse the argument array used for the
         * reflective call to save memory.
         */
        @Nullable
        protected MetaProperty lookupProperty(MetaClass metaClass, String name) {

     *
     * @param callable The callable to call
     * @param <T> Callable's return type
     * @return The value returned by {@link Callable#call()}
     */
    @Nullable
    public static <T> T uncheckedCall(Callable<T> callable) {
        try {
            return callable.call();
        } catch (Exception e) {
            throw throwAsUncheckedException(e);
        }

 * <strong>This type should only be extended and/or thrown by Gradle internal code.</strong>
 */
@Contextual
@HasInternalProtocol
public class ResolveException extends DefaultMultiCauseException {

    /**
     * Do not call this constructor.
     *
     * @deprecated This constructor will be removed in 9.0
     */
    @Deprecated
    public ResolveException(String message, Throwable cause) {
        super(message, cause);

    String getName();

    /**
     * This method or {@link #withInputStream(IoFunction)} ()} may or may not support being called more than
     * once per entry.  Use {@link #canReopen()} to determine if more than one call is supported.
     */
    byte[] getContent() throws IOException;

    /**
     * Declare an action to be run against this ZipEntry's content as a {@link InputStream}.

        extensionMapping.map("sourceSets", Callables.returning(new ArrayList<>()));
        extensionMapping.map("reportsDir", new Callable<File>() {
            @Override
            public File call() {
                return project.getExtensions().getByType(ReportingExtension.class).file(getReportName());
            }
        });
        withBasePlugin(new Action<Plugin>() {
            @Override