},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			client, controller := newController(t, tc.cidrs)
			controller.sync()
			expectAction(t, client.Actions(), tc.actions)
		})
	}
}

func expectAction(t *testing.T, actions []k8stesting.Action, expected [][]string) {
	t.Helper()
	if len(actions) != len(expected) {

				create := action.(k8stesting.CreateAction)
				namespaceInformer.Informer().GetIndexer().Add(create.GetObject())
				return true, create.GetObject(), nil
			})

			controller.sync()

			expectAction(t, clientset.Actions(), test.actions)
			namespaces, err := controller.namespaceLister.List(labels.Everything())
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}

			got := map[string]bool{}

	"regexp"
	"strconv"
	"strings"
)

// Expectation represents the expected result of some operation.
type Expectation struct {
	failure      bool
	errorMatcher *regexp.Regexp
}

// ExpectSuccess returns an Expectation that trivially expects success.
func ExpectSuccess() *Expectation {
	return new(Expectation)
}

// Check validates whether err conforms to the expectation. Returns
// an error if it does not conform.
//

    /**
     * Setup expectation when resolving with module metadata
     * @param expectation
     */
    void withModuleMetadata(@DelegatesTo(value = SingleArtifactResolutionResultSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> expectation) {
        expectation.resolveStrategy = Closure.DELEGATE_FIRST
        expectation.delegate = withModuleMetadataSpec
        expectation()
    }

    /**

						Type: "unsupported",
					},
				},
			},
			endpoints: nil,

			clusterMode:  expectation{error: true},
			endpointMode: expectation{error: true},
		},
		{
			name:      "missing service",
			services:  nil,
			endpoints: nil,

			clusterMode:  expectation{error: true},
			endpointMode: expectation{error: true},
		},
	}

	for _, test := range tests {

		AddedNamespace     *v1.Namespace
		UpdatedNamespace   *v1.Namespace
		DeletedConfigMap   *v1.ConfigMap
		UpdatedConfigMap   *v1.ConfigMap
		ExpectActions      []action
	}{
		"create new namespace": {
			AddedNamespace: newNs,
			ExpectActions:  []action{{verb: "create", name: RootCACertConfigMapName}},
		},
		"delete other configmap": {
			ExistingConfigMaps: []*v1.ConfigMap{otherConfigMap, caConfigMap},

        MavenArtifactResolutionExpectation expectation = new MavenArtifactResolutionExpectation(dependencyNotation, this)
        expectation.dependency = convertDependencyNotation(dependencyNotation)
        expectationSpec.resolveStrategy = Closure.DELEGATE_FIRST
        expectationSpec.delegate = expectation
        expectationSpec()

        expectation.validate()

    }

        IvyArtifactResolutionExpectation expectation = new IvyArtifactResolutionExpectation(dependencyNotation)
        expectation.dependency = convertDependencyNotation(dependencyNotation)
        expectationSpec.resolveStrategy = Closure.DELEGATE_FIRST
        expectationSpec.delegate = expectation
        expectationSpec()

        expectation.validate()
    }

				Line:   42,
				Column: 91,
			},
		},
	}
	for _, decl := range f.Decls {
		if fdecl, ok := decl.(*ast.FuncDecl); ok {
			ast.Walk(&Visitor{expectation, fset, t}, fdecl.Body)
		}
	}
	for ident, positions := range expectation {
		for _, position := range positions {
			if !position.Visited {
				t.Errorf("Position %d:%d missed for %s ident", position.Line, position.Column, ident)
			}
		}
	}

    private final boolean autoRelease;
    private boolean started;
    private boolean received;

    ResourceHandlerWrapper(Lock lock, ResourceExpectation expectation, WaitPrecondition owner, boolean isAutoRelease) {
        this.lock = lock;
        handler = expectation.create(this);
        this.owner = owner;
        this.autoRelease = isAutoRelease;
    }

    public String getDisplayName() {