setup:
        def task = createTask("task")
        when:
        def actions = task.actions
        and:
        def action = Mock(Action)

        actions.add(action)
        then:
        task.actions.size() == 1
        actions.size() == 1
    }

    def "can detect tasks with custom actions added"() {
        when:
        def task = createTask("task")

        then:

            }
            fileTree
        }
        copySpec.walk(_) >> { Action it -> it.execute(copySpecResolver) }
    }

    void actions(Closure... actions) {
        copySpecResolver.allCopyActions >> actions.collect { new ClosureBackedAction<>(it) }
    }

    void visit() {
        executer.execute(copySpec, delegate)
    }

/**
 * <p>A {@code TaskActionListener} is notified of the actions that a task performs.</p>
 *
 * @deprecated This type is not supported when configuration caching is enabled.
 */
@EventScope(Scope.Build.class)
@Deprecated
@DeprecatedInGradleScope
public interface TaskActionListener {
    /**
     * This method is called immediately before the task starts performing its actions.
     *

    private ImmutableActionSet<T> actions = ImmutableActionSet.empty();

    public void add(Action<? super T> action) {
        this.actions = actions.add(action);
    }

    public void clear() {
        actions = ImmutableActionSet.empty();
    }
    @Override
    public void execute(T t) {
        actions.execute(t);
    }

    public boolean isEmpty() {

        "actions.add(anAction)"                                     | "Task.getActions().add()"
        "actions.addAll([anAction])"                                | "Task.getActions().addAll()"
        "actions.set(0, anAction)"                                  | "Task.getActions().set(int, Object)"
        "actions.removeAll(actions)"                                | "Task.getActions().removeAll()"

    }

    public static <T> Builder unmanagedInstance(ModelReference<T> modelReference, final Factory<? extends T> factory) {
        return unmanagedInstance(modelReference, factory, Actions.doNothing());
    }

    public static <T> Builder unmanagedInstance(final ModelReference<T> modelReference, final Factory<? extends T> factory, final Action<? super MutableModelNode> initializer) {

    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/master' || contains(github.event.pull_request.labels.*.name, 'containers')

    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Configure JDK
        uses: actions/setup-java@v4
        with:
          distribution: 'zulu'

# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven

name: Java CI with Maven

on:
  push:
    branches:
    - master
    - "*.x"
  pull_request:
    branches:
    - master
    - "*.x"

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up JDK 17

    }

    private finishCheckpoint() {
        if (currentState == null) {
            if (!actions.empty) {
                currentState = DaemonsState.getWildcardState()
                finishCheckpoint()
            }
        } else {
            checkpoints << new DaemonsStateCheckpoint(currentState, *actions)
            actions.clear()
        }
    }

    branches:
      - master
  pull_request:
    branches:
      - master

permissions:
  contents: read

jobs:
  test:
    permissions:
      actions: write  # for styfle/cancel-workflow-action to cancel/stop running workflows
      contents: read  # for actions/checkout to fetch code
    name: "${{ matrix.root-pom }} on JDK ${{ matrix.java }} on ${{ matrix.os }}"
    strategy:
      matrix:
        os: [ ubuntu-latest ]