public class DelayedConfigurationActions implements ProjectConfigureAction {
    @Override
    public void execute(ProjectInternal projectInternal) {
        ProjectConfigurationActionContainer actions = projectInternal.getConfigurationActions();
        try {
            for (Action<? super ProjectInternal> action : actions.getActions()) {
                action.execute(projectInternal);
            }
        } finally {
            actions.finished();

import spock.lang.Specification

class DelayedConfigurationActionsTest extends Specification {
    final container = Mock(ProjectConfigurationActionContainer)
    final project = Stub(ProjectInternal) {
        getConfigurationActions() >> container
    }
    final action = new DelayedConfigurationActions()

    def "runs actions and discards actions when finished"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

    @Override
    ProjectStateInternal getState();

    @Override
    ExtensionContainerInternal getExtensions();

    ProjectConfigurationActionContainer getConfigurationActions();

    @Override
    ModelRegistry getModelRegistry();

    ClassLoaderScope getClassLoaderScope();

    ClassLoaderScope getBaseClassLoaderScope();

        }

        override fun getExtensions(): ExtensionContainerInternal {
            onAccess("extensions")
            return delegate.extensions
        }

        override fun getConfigurationActions(): ProjectConfigurationActionContainer {
            shouldNotBeUsed()
        }

        override fun getModelRegistry(): ModelRegistry {
            shouldNotBeUsed()
        }

        return task(options, task.toString(), configureClosure);
    }

    @Inject
    @Override
    public abstract ProjectConfigurationActionContainer getConfigurationActions();

    @Inject
    @Override
    public abstract ModelRegistry getModelRegistry();

    @Override
    protected DefaultObjectConfigurationAction createObjectConfigurationAction() {