// wil be returned.
func (s *SelectionPredicate) MatcherIndex(ctx context.Context) []MatchValue {
	var result []MatchValue
	for _, field := range s.IndexFields {
		if value, ok := s.Field.RequiresExactMatch(field); ok {
			result = append(result, MatchValue{IndexName: FieldIndex(field), Value: value})
		} else if field == "metadata.namespace" {

				Resource:          "pods",
			}),
			expected: []MatchValue{{IndexName: FieldIndex("metadata.namespace"), Value: "default"}},
		},
		"Match label": {
			labelSelector: "name=foo",
			fieldSelector: "uid=12345",
			indexLabels:   []string{"name"},
			indexFields:   []string{},
			ctx:           context.Background(),
			expected:      []MatchValue{{IndexName: LabelIndex("name"), Value: "foo"}},
		},

	found := false
	var matchHost host.Name
	var matchValue V

	for h, v := range wildcard {
		if strings.HasSuffix(needle, string(h[1:])) {
			if !found {
				matchHost = h
				matchValue = wildcard[h]
				found = true
			} else if host.MoreSpecific(h, matchHost) {
				matchHost = h
				matchValue = v
			}
		}
	}

	return matchHost, matchValue, found
}

        given:
        def attribute = Attribute.of(String)
        schema.attribute(attribute)

        expect:
        !schema.matcher().selectionSchema.matchValue(attribute, "a", "b")
        schema.matcher().selectionSchema.matchValue(attribute, "a", "a")

        !schema.matcher().isMatching(attribute, "a", "b")
        schema.matcher().isMatching(attribute, "a", "a")
    }

                boolean match = schema.matchValue(attribute, requestedValue.get(), coercedValue);
                if (!match) {
                    return false;
                }
            }
        }
        return true;
    }

    @Override
    public <T> boolean isMatching(Attribute<T> attribute, T candidate, T requested) {
        return schema.matchValue(attribute, requested, candidate);
    }

		// TODO: if multiple indexes match, return the one with the fewest items, so as to do as much filtering as possible.
		for _, matchValue := range matchValues {
			if result, err := w.store.ByIndex(matchValue.IndexName, matchValue.Value); err == nil {
				return result, w.resourceVersion, matchValue.IndexName, nil
			}
		}
		return w.store.List(), w.resourceVersion, "", nil
	}()

	return result, rv, index, err
}

     */
    @Nullable
    Set<Object> disambiguate(Attribute<?> attribute, @Nullable Object requested, Set<Object> candidates);

    boolean matchValue(Attribute<?> attribute, Object requested, Object candidate);

    @Nullable
    Attribute<?> getAttribute(String name);

    /**

// Everything accepts all objects.
var Everything = SelectionPredicate{
	Label: labels.Everything(),
	Field: fields.Everything(),
}

// MatchValue defines a pair (`<index name>`, `<value for that index>`).
type MatchValue struct {
	IndexName string
	Value     string
}

// Pass an UpdateFunc to Interface.GuaranteedUpdate to make an update
// that is guaranteed to succeed.

		t.Errorf("Used index %q but expected none to be used", indexUsed)
	}

	// list by label index.
	matchValues := []storage.MatchValue{
		{IndexName: "l:label", Value: "value1"},
		{IndexName: "f:spec.nodeName", Value: "node2"},
	}
	list, resourceVersion, indexUsed, err = store.WaitUntilFreshAndList(ctx, 5, matchValues)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if resourceVersion != 5 {

                return Collections.singleton(requested);
            }

            return null;
        }

        @Override
        public boolean matchValue(Attribute<?> attribute, Object requested, Object candidate) {
            if (requested.equals(candidate)) {
                return true;
            }

            CompatibilityCheckResult<Object> result = null;