for _, ip := range test.expectedIPs {
				_, err := r.ipAddressLister.Get(ip)
				if err != nil {
					t.Errorf("Unexpected error trying to get IPAddress %s object: %v", ip, err)
				}
			}

			expectAction(t, c.Actions(), test.actions)
			expectEvents(t, recorder.Events, test.events)
		})
	}

}

func TestRepairIPAddress_syncIPAddress(t *testing.T) {
	tests := []struct {
		name    string

	var tests = []struct {
		name                 string
		pvc                  *v1.PersistentVolumeClaim
		pv                   *v1.PersistentVolume
		recoverFeatureGate   bool
		disableNodeExpansion bool
		// expectations of test
		expectedResizeStatus  v1.ClaimResourceStatus
		expectedAllocatedSize resource.Quantity
		expectResizeCall      bool
	}{
		{

			// so we skup the errors and only assert on the actions
			// https://github.com/kubernetes/kubernetes/issues/99953
			_ = controller.sync(tCtx, tc.cidrSynced)
			expectAction(t, client.Actions(), tc.actions)

		})
	}
}

func makeServiceCIDR(name, primary, secondary string) *networkingapiv1alpha1.ServiceCIDR {
	serviceCIDR := &networkingapiv1alpha1.ServiceCIDR{

		// argument to errorCheck as it does double duty as both a
		// string that appears in the output, and as file name
		// openable relative to the test directory, containing text
		// expectations.
		//
		// So, we munge the file.
		stderr = strings.ReplaceAll(stderr, filepath.FromSlash("./rangeloop.go"), filename)

		if err := errorCheck(stderr, false, filename, filepath.Base(filename)); err != nil {

	var podUID string = string(pod.ObjectMeta.UID)
	ipProto := uint8(unix.IPPROTO_TCP)
	ctx, cancel := context.WithCancel(context.Background())
	fixture := getTestFixure(ctx)
	defer cancel()
	setupLogging()

	// expectations
	fixture.ipsetDeps.On("addIP",
		"foo-v4",
		netip.MustParseAddr("3.3.3.3"),
		ipProto,
		podUID,
		false,
	).Return(nil)

	fixture.ipsetDeps.On("addIP",
		"foo-v4",

    }

    private void add(HttpStub httpStub, HttpServer.ActionSupport action) {
        HttpServer.HttpExpectOne expectation = new HttpServer.HttpExpectOne(action, [httpStub.request.method], httpStub.request.path)
        expectations << expectation
        addHandler(new AbstractHandler() {
            @Override

    }

    def "explicit configuration selection in ivy modules is supported if targeting a ivy module"() {
        given:
        // use a different name if selection is supported to not follow the default expectations defined in leaksRuntime()
        String targetRepoName = "ivy-select"
        setupRepositories([targetRepoName, 'ivy'])
        repository('ivy') {
            "org:ivy:1.0" {
                withModule(IvyModule) {

            request2.release()
        }
        server.stop()

        then:
        instant.aDone > instant.aBlocked
        instant.bDone > instant.bBlocked
    }

    def "can chain expectations"() {
        given:
        server.expectConcurrent("a", "b")
        server.expect("c")
        def handle = server.expectConcurrentAndBlock(2, "d", "e")
        server.expect("f")
        server.start()

    private final static Logger logger = LoggerFactory.getLogger(HttpServer.class)

    protected Matcher expectedUserAgent = null

    List<ServerExpectation> expectations = []

    boolean chunkedTransfer = false

    org.gradle.api.Action<HttpServletRequest> beforeHandle
    org.gradle.api.Action<HttpServletRequest> afterHandle

    enum SupportedHash {

        when:
        fails ':checkDeps'

        then:
        errorOutput.contains("Plugin [id: 'org.gradle.repo-conventions'] was not found in any of the following sources")

        // real expectations below

        /*
        when:
        repositoryInteractions {
            'org:from-buildsrc:1.0' {
                expectResolve()
            }
            'org:from-main-build:1.0' {