*/
    def <T> Action<T> serializable(Action<T> action, ClassLoader target) {
        String src = """
class TestAction implements ${Action.class.name}, ${Serializable.class.name}
{
    Object key

    void execute(Object target) {
        def action = ${SerializableMockHelper.class.name}.ACTIONS.remove(key)
        action.execute(target)
    }
}
"""

        attributesMutator = GUtil.elvis(attributesMutator, Actions.doNothing());
        capabilitiesMutator = GUtil.elvis(capabilitiesMutator, Actions.doNothing());

        if (delegate instanceof DefaultMinimalDependencyVariant) {
            this.attributesMutator = Actions.composite(((DefaultMinimalDependencyVariant) delegate).attributesMutator, attributesMutator);

        return new BiAction<A, B>() {
            @Override
            public void execute(A a, B b) {
                for (BiAction<? super A, ? super B> action : actions) {
                    action.execute(a, b);
                }
            }
        };
    }

    public static <A> BiAction<A, Object> usingFirstArgument(final Action<? super A> action) {

     *
     * @see BuildOperationExecutor#runAllWithAccessToProjectState(Action)
     */
    <O extends RunnableBuildOperation> void runAll(Action<BuildOperationQueue<O>> schedulingAction, BuildOperationConstraint buildOperationConstraint);

    /**
     * Same as {@link #runAll(Action)}. However, the actions are allowed to access mutable project state. In general, this is more likely to

    }

    public ToolType getToolType() {
        return toolType;
    }

    @Override
    public void withArguments(Action<? super List<String>>  action) {
        argActions.add(action);
    }

    @Override
    public Action<List<String>> getArgAction() {
        return Actions.composite(argActions);
    }

        linker.execute(spec)

        then:
        1 * operationLogger.getLogLocation() >> LOG_LOCATION
        1 * buildOperationExecutor.runAll(commandLineTool, _) >> { worker, action -> action.execute(queue) }
        1 * invocationContext.getArgAction() >> Actions.doNothing()
        1 * invocationContext.createInvocation("linking lib", outputFile.parentFile, expectedArgs, operationLogger) >> invocation
        1 * queue.add(invocation)

    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately after a project is evaluated.
     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions
     * @since 8.8
     */
    @Incubating
    void afterProject(IsolatedAction<? super Project> action);

    public void create(String name) {
        create(name, elementType, Actions.doNothing());
    }

    @Override
    public void create(String name, Action<? super T> configAction) {
        create(name, elementType, configAction);
    }

    @Override
    public <S extends T> void create(String name, Class<S> type) {
        create(name, type, Actions.doNothing());
    }

    @Override

        }
        return null;
    }

    private void applyTo(VcsMappingInternal mapping) {
        Actions.composite(rootVcsMappings).execute(mapping);
        if (!mapping.hasRepository()) {
            Set<VersionControlSpec> resolutions = new HashSet<>();
            for (Gradle gradle : vcsMappings.keySet()) {
                Actions.composite(vcsMappings.get(gradle)).execute(mapping);
                if (mapping.hasRepository()) {

    }

    @Override
    public CopySpec copySpec(Action<? super CopySpec> action) {
        return Actions.with(copySpec(), action);
    }

    @Override
    public CopySpec copySpec() {
        return fileOperations.copySpec();
    }

    @Override
    public WorkResult copy(Action<? super CopySpec> action) {
        return fileOperations.copy(action);
    }

    @Override