},
                                "exact_match_map": {
                                  "map": {
                                    "80": {
                                      "action": {
                                        "name": "inbound-vip|80||sleep.default.svc.cluster.local-http",
                                        "typed_config": {

	mockClient := &fake.Clientset{}

	var (
		testCount  int64
		test1Count int64
	)
	mockClient.AddReactor("list", "limitranges", func(action core.Action) (bool, runtime.Object, error) {
		switch action.GetNamespace() {
		case "test":
			atomic.AddInt64(&testCount, 1)
		case "test1":
			atomic.AddInt64(&test1Count, 1)
		default:
			t.Error("unexpected namespace")
		}

	evt := lc.eval(obj1, now)
	if evt.Action != TransitionAction {
		t.Fatalf("Expected action: %s but got %s", TransitionAction, evt.Action)
	}
	if evt.StorageClass != "TIER-1" {
		t.Fatalf("Expected TIER-1 but got %s", evt.StorageClass)
	}

	evt = lc.eval(obj2, now)
	if evt.Action != TransitionVersionAction {
		t.Fatalf("Expected action: %s but got %s", TransitionVersionAction, evt.Action)
	}
	if evt.StorageClass != "TIER-2" {

//
// Also ensures NotFound action is enforced correctly by deleting all found
// params and ensuring the Action is used.
//
// This test is not meant to test every possible scenario of matching/not matching:
// only that each ParamRef CAN be evaluated correctly for both cluster scoped
// and namespace-scoped request kinds, and that the failure action is correctly
// applied.

	exportContentStrings := map[string]string{

			revision *apps.ControllerRevision
		}
		reactor core.ReactionFunc
		err     bool
	}
	conflictSuccess := func(action core.Action) (bool, runtime.Object, error) {
		defer func() {
			conflictAttempts++
		}()
		switch action.(type) {

		case core.UpdateActionImpl:
			update := action.(core.UpdateAction)
			if conflictAttempts < 2 {

* filter them (using link:{javadocPath}/org/gradle/api/file/FileTree.html#matching-org.gradle.api.Action-[FileTree.matching(org.gradle.api.Action)] and Ant-style patterns)
* merge them

You can also traverse file trees using the link:{javadocPath}/org/gradle/api/file/FileTree.html#visit-org.gradle.api.Action-[FileTree.visit(org.gradle.api.Action)] method.
All of these techniques are demonstrated in the following example:

====

	updates, gets := 0, 0
	for _, a := range fakeClient.Actions() {
		if a.GetResource().Resource != "replicasets" {
			t.Errorf("Unexpected action %+v", a)
			continue
		}

		switch action := a.(type) {
		case core.GetAction:
			gets++
			// Make sure the get is for the right ReplicaSet even though the update failed.
			if action.GetName() != rs.Name {

                                },
                                "exact_match_map": {
                                  "map": {
                                    "8000": {
                                      "action": {
                                        "name": "inbound-vip|8000||httpbin.default.svc.cluster.local-http",
                                        "typed_config": {

	fakeClient.AddReactor("get", "persistentvolumes", func(action core.Action) (bool, runtime.Object, error) {
		return true, pv, nil
	})
	fakeClient.AddReactor("patch", "persistentvolumeclaims", func(action core.Action) (bool, runtime.Object, error) {
		if action.GetSubresource() == "status" {
			return true, pvc, nil
		}
		return true, nil, fmt.Errorf("no reaction implemented for %s", action)
	})