"internal/abi.InterfaceType": true,
		"internal/abi.ITab":          true,
	}

	found := findTypes(t, dwarf, want)
	if len(found) != len(want) {
		t.Errorf("found %v, want %v", found, want)
	}
}

func findTypes(t *testing.T, dw *dwarf.Data, want map[string]bool) (found map[string]bool) {
	found = make(map[string]bool)
	rdr := dw.Reader()
	for entry, err := rdr.Next(); entry != nil; entry, err = rdr.Next() {

    @Override
    protected DynamicInvokeResult _configure(String name) {
        return DynamicInvokeResult.found(_container.create(name));
    }

    @Override
    protected DynamicInvokeResult _configure(String name, Object[] params) {
        if (params.length == 1 && params[0] instanceof Closure) {
            return DynamicInvokeResult.found(_container.create(name, (Closure<?>) params[0]));

     */
    File getJavaExecutable() throws JavaHomeException;

    /**
     * @return the executable
     * @throws JavaHomeException when executable cannot be found
     */
    File getJavacExecutable() throws JavaHomeException;

    /**
     * @return the executable
     * @throws JavaHomeException when executable cannot be found
     */

    conditions:
    - lastTransitionTime: fake
      message: No errors found
      reason: Accepted
      status: "True"
      type: Accepted
    - lastTransitionTime: fake
      message: No errors found
      reason: NoConflicts
      status: "False"
      type: Conflicted
    - lastTransitionTime: fake
      message: No errors found
      reason: Programmed
      status: "True"
      type: Programmed

		panic(fmt.Sprintf("key %q unexpectedly not present", []byte("c")))
	}

	if v, found := m.Find([]byte("a")); !found {
		panic(fmt.Sprintf("did not find %q", []byte("a")))
	} else if v != 'a' {
		panic(fmt.Sprintf("key %q returned wrong value %c, expected %c", []byte("a"), v, 'a'))
	}
	if v, found := m.Find([]byte("c")); !found {
		panic(fmt.Sprintf("did not find %q", []byte("c")))
	} else if v != 'x' {

    private static final DynamicInvokeResult NULL = new DynamicInvokeResult(null);

    public static DynamicInvokeResult found(@Nullable Object value) {
        return value == null ? found() : new DynamicInvokeResult(value);
    }

    public static DynamicInvokeResult found() {
        return DynamicInvokeResult.NULL;
    }

    public static DynamicInvokeResult notFound() {

		{"TEXT", "$\"foo\", 0, $1", "TEXT symbol \"<erroneous symbol>\" must be a symbol(SB)"},
		{"TEXT", "$0É:0, 0, $1", "expected end of operand, found É"}, // Issue #12467.
		{"TEXT", "$:0:(SB, 0, $1", "expected '(', found 0"},          // Issue 12468.
		{"TEXT", "@B(SB),0,$0", "expected '(', found B"},             // Issue 23580.
		{"TEXT", "foo<ABIInternal>(SB),0", "ABI selector only permitted when compiling runtime, reference was to \"foo\""},

// of found errors and reports discrepancies.
func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]string, found scanner.ErrorList) {
	t.Helper()
	for _, error := range found {
		// error.Pos is a token.Position, but we want
		// a token.Pos so we can do a map lookup
		pos := getPos(fset, error.Pos.Filename, error.Pos.Offset)
		if msg, found := expected[pos]; found {

	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if unknown, found, err := unstructured.NestedInt64(obj.UnstructuredContent(), "metadata", "unknown"); err != nil {
		t.Errorf("unexpected error getting metadata.unknown: %v", err)
	} else if found {
		t.Errorf("unexpected metadata.unknown=%#v: expected this to be pruned", unknown)
	}

		}
	}
}

func ValidateClusters(t testing.TB, ls []*cluster.Cluster) {
	found := sets.New[string]()
	for _, l := range ls {
		if found.Contains(l.Name) {
			t.Errorf("duplicate cluster name %v", l.Name)
		}
		found.Insert(l.Name)
		ValidateCluster(t, l)
	}
}

func ValidateCluster(t testing.TB, c *cluster.Cluster) {