}

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name) {
        assertMutable("resolvable(String)");
        return registerResolvableConfiguration(name, Actions.doNothing());
    }

    @Override
    public NamedDomainObjectProvider<ResolvableConfiguration> resolvable(String name, Action<? super ResolvableConfiguration> action) {

        when:
        strategy.dependencySubstitutionRule.execute(details)

        then:
        _ * dependencySubstitutions.ruleAction >> Actions.doNothing()
        _ * globalDependencySubstitutions.ruleAction >> Actions.doNothing()
        _ * details.getRequested() >> DefaultModuleComponentSelector.newSelector(mid, new DefaultMutableVersionConstraint("1.0"))

    @Override
    public ExtensiblePolymorphicDomainObjectContainer<JvmTestSuiteTarget> getTargets() {
        return targets;
    }

    @Override
    public void useJUnit() {
        useJUnit(Actions.doNothing());
    }

    @Override
    public void useJUnit(String version) {
        useJUnit(getProviderFactory().provider(() -> version));
    }

    @Override

        1 * action.execute({ DefaultDependencyResolveDetails details ->
            details.requested == moduleOldRequested
        })
        1 * moduleDetails.artifactSelection(Actions.doNothing())
        0 * _

        def projectOldRequested = DefaultModuleVersionSelector.newSelector(mid, "1.5")
        def projectTarget = TestComponentIdentifiers.newSelector(":api")

    testExecutor.execute(doNothing());
    mock.assertLastMethodCalled("execute");
  }

  public void testSubmit() throws InterruptedException, ExecutionException {
    {
      MockExecutor mock = new MockExecutor();
      TestExecutor testExecutor = new TestExecutor(mock);
      Future<?> f = testExecutor.submit(doNothing());
      mock.assertLastMethodCalled("submit");
      f.get();
    }

    testExecutor.execute(doNothing());
    mock.assertLastMethodCalled("execute");
  }

  public void testSubmit() throws InterruptedException, ExecutionException {
    {
      MockExecutor mock = new MockExecutor();
      TestExecutor testExecutor = new TestExecutor(mock);
      Future<?> f = testExecutor.submit(doNothing());
      mock.assertLastMethodCalled("submit");
      f.get();
    }

        when:
        cachePolicy.eachArtifact(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)

        when:
        cachePolicy.eachDependency(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)

        when:
        cachePolicy.eachModule(Actions.doNothing())
        then:
        1 * validator.validateMutation(STRATEGY)
    }

                public SneakyTask() {
                    ${snippets.body}
                }

                @TaskAction
                public void doNothing() {}
            }
        """

        buildFile("""
            tasks.register("sneakyTask", SneakyTask) {}
        """)

        when:
        configurationCacheFails(":sneakyTask")

        then:

        })
        task.actions.size() == 1
    }

    def "doFirst() adds actions to the start of action list"() {
        given:
        Action<Task> action1 = Actions.doNothing()
        Action<Task> action2 = Actions.doNothing()

        expect:
        defaultTask.is(defaultTask.doFirst(action1))
        1 == defaultTask.actions.size()

        defaultTask.is(defaultTask.doFirst(action2))

        1 * action3.execute("value")
        0 * _
    }

    def "ignores no-op actions when creating a composite"() {
        expect:
        ImmutableActionSet.of(Actions.doNothing(), Actions.doNothing()).is(ImmutableActionSet.empty())
    }

    def "ignores empty sets is a composite"() {
        expect: