}

		actionSet := sets.NewString()
		for _, action := range kubeClient.Actions() {
			actionSet.Insert(strings.Join([]string{action.GetVerb(), action.GetResource().Resource, action.GetSubresource()}, "-"))
		}
		if !actionSet.IsSuperset(testCase.expectedActionSet) {

        container.actions == [action]
    }

    def "can add action as closure"() {
        def run = false
        def action = { run = true }

        when:
        container.add(action)

        then:
        container.actions.size() == 1

        when:
        container.actions[0].execute(Stub(ProjectInternal))

        then:
        run
    }

import org.opensearch.action.admin.indices.alias.Alias;
import org.opensearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
import org.opensearch.action.admin.indices.alias.get.GetAliasesResponse;
import org.opensearch.action.admin.indices.create.CreateIndexResponse;
import org.opensearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.opensearch.action.admin.indices.get.GetIndexResponse;

        where:
        methodUnderTest         | callableType | callable
        "withMutationDisabled"  | "Action"     | Actions.doNothing()
        "withMutationEnabled"   | "Action"     | Actions.doNothing()
    }

    def "call to #methodUnderTest(#callableType) inside withMutationEnabled(Action) does enable disallow check outside scope"() {
        def aMethodUnderTest = methodUnderTest
        def aCallable = callable

	if len(actions) != len(expected) {
		t.Fatalf("Expected at least %d actions, got %d \ndiff: %v", len(expected), len(actions), cmp.Diff(expected, actions))
	}

	for i, action := range actions {
		verb := expected[i][0]
		if action.GetVerb() != verb {
			t.Errorf("Expected action %d verb to be %s, got %s", i, verb, action.GetVerb())
		}
		resource := expected[i][1]
		if action.GetResource().Resource != resource {

        final Set<ResolvedComponentResult> out = new LinkedHashSet<>();
        eachElement(getRoot(), Actions.doNothing(), Actions.doNothing(), out);
        return out;
    }

    @Override
    public void allComponents(final Action<? super ResolvedComponentResult> action) {
        eachElement(getRoot(), action, Actions.doNothing(), new HashSet<>());
    }

    @Override
    @SuppressWarnings("rawtypes")

import org.opensearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse;
import org.opensearch.action.admin.indices.mapping.get.GetFieldMappingsResponse.FieldMappingMetadata;
import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponse;
import org.opensearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;

		actions = appendIf(actions, action{"GET", itemPath, nameParams, namer, false}, isGetter)
		if getSubpath {
			actions = appendIf(actions, action{"GET", itemPath + "/{path:*}", proxyParams, namer, false}, isGetter)
		}
		actions = appendIf(actions, action{"PUT", itemPath, nameParams, namer, false}, isUpdater)
		actions = appendIf(actions, action{"PATCH", itemPath, nameParams, namer, false}, isPatcher)

// most basic unit of action applied to the StableHLO graph. Derived classes
// should override the `Run` method to implement the action.
class Component {
 public:
  virtual ~Component() = default;

  // Runs the action to the StableHLO graph, passed by the `module_op`. `config`
  // should provide information necessary to configure the action's behavior.
  virtual absl::StatusOr<ModuleOp> Run(

            }
        """

        expect:
        def models = withConnection {
            def action = action(new ActionRunsMultipleLevelsOfNestedActions())
            action.standardOutput = System.out
            action.standardError = System.err
            action.addArguments("--parallel")
            action.run()
        }

        models.size() == 3
        models.every { it.projects.size() == 5 }
    }