public interface DependencySubstitutionRules {
    DependencySubstitutionRules NO_OP = new DependencySubstitutionRules() {
        @Override
        public Action<DependencySubstitution> getRuleAction() {
            return Actions.doNothing();
        }

        @Override
        public boolean rulesMayAddProjectDependency() {
            return false;
        }
    };

    Action<DependencySubstitution> getRuleAction();

    }

    @Override
    public PublishArtifact add(String configurationName, Object artifactNotation) {
        return pushArtifact(configurationContainer.getByName(configurationName), artifactNotation, Actions.doNothing());
    }

    @Override
    @SuppressWarnings("rawtypes")
    public PublishArtifact add(String configurationName, Object artifactNotation, Closure configureClosure) {

    }

    def "toolchain service dependencies are satisfied"() {
        expect:
        project.extensions.getByType(JavaToolchainService).launcherFor(Actions.doNothing()).get().executablePath.asFile.isFile()
    }

        @Override
        public void execute(Object o, Object o2) {

        }
    };

    private BiActions() {
    }

    public static BiAction<Object, Object> doNothing() {
        return NOOP;
    }

    public static <A, B> BiAction<A, B> composite(final BiAction<? super A, ? super B>... actions) {
        return new BiAction<A, B>() {
            @Override

        "task '" + getTask().getPath() + "'" ==  getTask().toString()
    }

    def testSetActions() {
        when:
        Action action1 = Actions.doNothing()
        getTask().actions = [action1]

        Action action2 = Actions.doNothing()
        getTask().actions = [action2]

        then:
        [new AbstractTask.TaskActionWrapper(action2, "doLast(Action)")] ==  getTask().actions
    }

    }

    void prepareWrapper(URI distributionUri = distribution.binDistribution.toURI(), Action<GradleExecuter> action = Actions.doNothing()) {
        def executer = new InProcessGradleExecuter(distribution, temporaryFolder)
        executer.beforeExecute(action)
        executer.withArguments("wrapper", "--gradle-distribution-url", distributionUri.toString()).run()

        this.instance = instance;
        this.onClose = onClose;
    }

    public static <T> ModelView<T> of(ModelPath path, ModelType<T> type, T instance) {
        return of(path, type, instance, Actions.doNothing());
    }

    public static <T> ModelView<T> of(ModelPath path, ModelType<T> type, T instance, Action<? super T> onClose) {
        return new InstanceModelView<T>(path, type, instance, onClose);
    }

                    if (releases && version.endsWith("-SNAPSHOT")) {
                        details.notFound();
                    }
                }
            };
            if (filter == Actions.doNothing()) {
                return action;
            }
            return Actions.composite(filter, action);
        }
        return filter;
    }

    @Override

                    if (instance instanceof ReusableAction) {
                        reusableRules[i] = instance;
                    } else {
                        reusableRules[i] = Actions.doNothing();
                    }
                }
                instance.execute(target);
            } catch (Throwable t) {
                exceptionHandler.handleException(target, t);
            }
            i++;

        when: rules.all(Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(Closure.IDENTITY)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(ruleSource)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.withModule("something:else", Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)