// Most probably it's exponential backoff
				time.Sleep(10 * time.Millisecond)
				continue
			}
			break
		}
		actions := client.Actions()

		if !reflect.DeepEqual(actions, test.expectedActions) {
			t.Errorf("Test %q: action not expected\nExpected:\n%s\ngot:\n%s", test.name, dump.Pretty(test.expectedActions), dump.Pretty(actions))
		}

	}

     * @param action the action to add
     */
    public void addAction(Action<? super T> action) {
        actions.add(action);
    }

    /**
     * Transforms a property list object. This will modify the
     * original.
     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override
    public T transform(T original) {

      # contents: read
      # actions: read

    steps:
      - name: "Checkout code"
        uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
        with:
          persist-credentials: false

      - name: "Run analysis"
        uses: ossf/scorecard-action@dc50aa9510b46c811795eb24b2f1ba02a914e534 # v2.3.3
        with:

     *
     * <p>When one or more actions fail with an exception, the exceptions are rethrown by this method and no result is returned.</p>
     *
     * @param actions The actions to run.
     * @param <T> the result type.
     * @return The action results. These are returned in the same order as the actions that produce them.
     * @since 6.8

        class Initial() : State() {

            private
            val actions = mutableListOf<RegisteredFlowAction>()

            override val pendingActions: List<RegisteredFlowAction>
                get() = actions

            override fun add(registeredFlowAction: RegisteredFlowAction) {
                synchronized(actions) {
                    actions.add(registeredFlowAction)
                }
            }

        1 * action.run(consumerConnection)
        0 * _._
    }

    def reusesConnection() {
        def action2 = Mock(ConsumerAction)

        when:
        connection.run(action)
        connection.run(action2)

        then:
        1 * loggingProvider.getProgressLoggerFactory() >> progressLoggerFactory

        private final File baseDir;
        private final CleanupAction action;

        ScopedCleanupAction(File baseDir, CleanupAction action) {
            this.baseDir = baseDir;
            this.action = action;
        }

        @Override
        public void clean(CleanableStore cleanableStore, CleanupProgressMonitor progressMonitor) {
            action.clean(new CleanableSubDir(cleanableStore, baseDir), progressMonitor);
        }

import java.util.function.Supplier;

public interface AsyncCacheAccess {
    /**
     * Submits the given action for execution without waiting for the result.
     *
     * An implementation may execute the action immediately or later. All actions submitted by this method must complete before any action submitted to {@link #read(Supplier)} is executed. Actions submitted using this method must run in the order that they are submitted.
     */

name: "Code scanning - action"

on:
  push:
    branches: [ main, master, release ]
  schedule:
    - cron: '0 5 * * *'

permissions: {}

jobs:
  CodeQL-Build:
    permissions:
      actions: read  # for github/codeql-action/init to get workflow details
      contents: read  # for actions/checkout to fetch code
      security-events: write  # for github/codeql-action/analyze to upload SARIF results
    runs-on: ubuntu-latest

                    @Internal
                    List<Closure> actions = []

                    void action() {
                        actions.add { "Groovy closure in task with delegate=\$delegate, owner=\${owner.class.name}, this=\${this.class.name}" }
                    }

                    void actionWithDelegate() {