}
	return nil
}

func TestGetNodeIPs(t *testing.T) {
	type expectation struct {
		matchAll bool
		ips      sets.Set[string]
	}

	testCases := []struct {
		name          string
		cidrs         []string
		itfAddrsPairs []InterfaceAddrsPair
		expected      map[v1.IPFamily]expectation
	}{
		{
			name:  "IPv4 single",
			cidrs: []string{"10.20.30.0/24"},

}

func (s *TestServer) Verify(resp *discovery.DiscoveryResponse, expectations ...Expectation) *discovery.DiscoveryResponse {
	s.t.Helper()
	if len(resp.Resources) != len(expectations) {
		s.t.Fatalf("expected %d resources, got %d", len(expectations), len(resp.Resources))
	}
	got := xdstest.ExtractTLSSecrets(s.t, resp.Resources)
	for _, e := range expectations {
		scrt := got[e.ResourceName]
		var expectationKey []byte

		}
	}
}

type expectation func(*BiMultimap) error

func forwardSelect(key Key, want ...Key) expectation {
	return func(m *BiMultimap) error {
		got, _ := m.Select(key)
		if !unorderedEqual(want, got) {
			return fmt.Errorf("forward select %v wanted %v. got %v.", key, want, got)
		}
		return nil
	}
}

func reverseSelect(key Key, want ...Key) expectation {
	return func(m *BiMultimap) error {

        }

        if (expectGetArtifact) {
            expectGetArtifact.each { ArtifactExpectation expectation ->
                def artifacts = []
                if (expectation.spec) {
                    if (expectation.spec instanceof VariantArtifacts) {
                        artifacts.addAll(expectation.spec.toArtifacts(module))
                    } else if (module instanceof MavenModule) {

                    assertRequest(httpStub, request)
                    if (expectation.run) {
                        println("This expectation for the request [${request.method} :${request.pathInfo}] was already handled - skipping")
                        return
                    }
                    if (!baseRequest.isHandled()) {
                        expectation.atomicRun.set(true)
                        action.handle(request, response)

                    assertRequest(httpStub, request)
                    if (expectation.run) {
                        println("This expectation for the request [${request.method} :${request.pathInfo}] was already handled - skipping")
                        return
                    }
                    if (!((Request) request).isHandled()) {
                        expectation.atomicRun.set(true)
                        action.handle(request, response)

    }

    private HttpResourceInteraction addOneRequestExpecation(String path, boolean matchPrefix, Collection<String> methods, Action action, OneRequestServerExpectation expectation) {
        expectations << expectation
        add(path, matchPrefix, methods, new AbstractHandler() {
            @Override

            modelsCreated(new ModelRequestExpectation(path, modelNames))
        }

        void modelsCreated(ModelRequestExpectation expectation) {
            projectsConfigured(expectation.path)
            runsTasks = false
            loadsOnStore = false
            models.add(expectation)
        }

        void modelsQueriedAndNotPresent(String... paths) {
            for (path in paths) {

        List<ResourceExpectation> expectations = new ArrayList<>();
        for (ExpectedRequest call : expectedCalls) {
            expectations.add((ResourceExpectation) call);
        }
        addNonBlockingHandler(expectations);
    }

    private void addNonBlockingHandler(final Collection<? extends ResourceExpectation> expectations) {

        RoundingMode mode = entry.getKey();
        Double expectation = entry.getValue();
        assertWithMessage("roundToDouble(" + input + ", " + mode + ")")
            .that(BigDecimalMath.roundToDouble(input, mode))
            .isEqualTo(expectation);
      }

      if (!expectedValues.containsKey(UNNECESSARY)) {