attributesMutator = GUtil.elvis(attributesMutator, Actions.doNothing());
        capabilitiesMutator = GUtil.elvis(capabilitiesMutator, Actions.doNothing());

        if (delegate instanceof DefaultMinimalDependencyVariant) {
            this.attributesMutator = Actions.composite(((DefaultMinimalDependencyVariant) delegate).attributesMutator, attributesMutator);

                        details.notFound();
                    }
                }
            };
            if (filter == Actions.doNothing()) {
                return action;
            }
            return Actions.composite(filter, action);
        }
        return filter;
    }

    @Override
    public RepositoryContentDescriptorInternal asMutableCopy() {

        return new BiAction<A, B>() {
            @Override
            public void execute(A a, B b) {
                for (BiAction<? super A, ? super B> action : actions) {
                    action.execute(a, b);
                }
            }
        };
    }

    public static <A> BiAction<A, Object> usingFirstArgument(final Action<? super A> action) {

}

func TestNoConfigMap(t *testing.T) {
	signer, cl, _, _, err := newSigner()
	if err != nil {
		t.Fatalf("error creating Signer: %v", err)
	}
	signer.signConfigMap(context.TODO())
	verifyActions(t, []core.Action{}, cl.Actions())
}

func TestSimpleSign(t *testing.T) {
	signer, cl, secrets, configMaps, err := newSigner()
	if err != nil {
		t.Fatalf("error creating Signer: %v", err)
	}

	cm := newConfigMap("", "")

     *
     * @see BuildOperationExecutor#runAllWithAccessToProjectState(Action)
     */
    <O extends RunnableBuildOperation> void runAll(Action<BuildOperationQueue<O>> schedulingAction, BuildOperationConstraint buildOperationConstraint);

    /**
     * Same as {@link #runAll(Action)}. However, the actions are allowed to access mutable project state. In general, this is more likely to

				}
				if expectedActions == 2 {
					action := fakeClient.Actions()[1]
					if !action.Matches("update", "clusterroles") {
						t.Fatalf("unexpected action %#v", action)
					}
					updateAction, ok := action.(clienttesting.UpdateAction)
					if !ok {
						t.Fatalf("unexpected action %#v", action)
					}

    private final MutableActionSet<Properties> actions = new MutableActionSet<Properties>();

    /**
     * Adds an action to be executed when properties are transformed.
     * @param action the action to add
     */
    public void addAction(Action<? super Properties> action) {
        actions.add(action);
    }

    /**
     * Transforms a properties object.  This will modify the

     */
    void add(Action<? super ProjectInternal> action);

    /**
     * Registers an action to execute to configure the project. Actions are executed in an arbitrary order.
     */
    void add(@DelegatesTo(ProjectInternal.class) Closure action);

}

func expectAction(t *testing.T, actions []k8stesting.Action, expected [][]string) {
	t.Helper()
	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())

			cleaner.evaluateSATokens(ctx)

			actions := client.Actions()
			if len(actions) != len(tc.ExpectedActions) {
				t.Fatalf("got %d actions, wanted %d actions", len(actions), len(tc.ExpectedActions))
			}
			for i, action := range actions {
				if len(tc.ExpectedActions) < i+1 {
					t.Errorf("%s: %d unexpected actions: %+v", k, len(actions)-len(tc.ExpectedActions), actions[i:])
					break
				}