var consumed, count int
		consumed, count, names = syscall.ParseDirent(buf[:n], -1, names)
		t.Logf("ParseDirent: %d new name(s)", count)
		if consumed != n {
			t.Fatalf("ParseDirent: consumed %d bytes; expected %d", consumed, n)
		}
	}

	slices.Sort(names)
	t.Logf("names: %q", names)

	if len(names) != 10 {
		t.Errorf("got %d names; expected 10", len(names))
	}
	for i, name := range names {

			break
		}
		name := rec[namoff : namoff+namlen]
		for i, c := range name {
			if c == 0 {
				name = name[:i]
				break
			}
		}
		// Check for useless names before allocating a string.
		if string(name) == "." || string(name) == ".." {
			continue
		}
		max--
		count++
		names = append(names, string(name))
	}
	return origlen - len(buf), count, names

				{Name: names.NodeAffinity, Weight: ptr.To[int32](2)},
				{Name: names.NodePorts},
				{Name: names.NodeResourcesFit, Weight: ptr.To[int32](1)},
				{Name: names.VolumeRestrictions},
				{Name: names.NodeVolumeLimits},
				{Name: names.VolumeBinding},
				{Name: names.VolumeZone},
				{Name: names.PodTopologySpread, Weight: ptr.To[int32](2)},
				{Name: names.InterPodAffinity, Weight: ptr.To[int32](2)},
				{Name: names.DefaultPreemption},

	}
}

type globOnly struct{ GlobFS }

func (globOnly) Open(name string) (File, error) { return nil, ErrNotExist }

func TestGlobMethod(t *testing.T) {
	check := func(desc string, names []string, err error) {
		t.Helper()
		if err != nil || len(names) != 1 || names[0] != "hello.txt" {
			t.Errorf("Glob(%s) = %v, %v, want %v, nil", desc, names, err, []string{"hello.txt"})
		}
	}

		if chk := field.TagSettings["CHECK"]; chk != "" {
			names := strings.Split(chk, ",")
			if len(names) > 1 && regEnLetterAndMidline.MatchString(names[0]) {
				checks[names[0]] = CheckConstraint{Name: names[0], Constraint: strings.Join(names[1:], ","), Field: field}
			} else {
				if names[0] == "" {
					chk = strings.Join(names[1:], ",")
				}
				name := schema.namer.CheckerName(schema.Table, field.DBName)

package sidecar

import (
	"sort"

	"istio.io/istio/pkg/config/resource"
)

func getNames(entries []*resource.Instance) []string {
	names := make([]string, 0, len(entries))
	for _, rs := range entries {
		names = append(names, string(rs.Metadata.FullName.Name))
	}
	sort.Strings(names)
	return names

	"istio.io/istio/pkg/config/resource"
	"istio.io/istio/pkg/config/schema/gvk"
)

func getNames(entries []*resource.Instance) []string {
	names := make([]string, 0, len(entries))
	for _, rs := range entries {
		names = append(names, string(rs.Metadata.FullName.Name))
	}
	sort.Strings(names)
	return names
}

func fetchMeshConfig(c analysis.Context) *v1alpha1.MeshConfig {
	var meshConfig *v1alpha1.MeshConfig

     *
     * @see KaResolveExtensionFile
     */
    public abstract fun getTopLevelClassifierNames(): Set<Name>

    /**
     * Returns the set of top-level callable (functions and properties) names in the file.
     *

				Names: []string{
					"gcr.io/30:latest",
				},
				SizeBytes: int64(30 * mb),
			},
		},
	}

	node203040 := v1.NodeStatus{
		Images: []v1.ContainerImage{
			{
				Names: []string{
					"gcr.io/20:latest",
				},
				SizeBytes: int64(20 * mb),
			},
			{
				Names: []string{
					"gcr.io/30:latest",
				},
				SizeBytes: int64(30 * mb),
			},
			{
				Names: []string{

        }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        sequence {
            subScopes.forEach { yieldAll(it.getCallableSymbols(names)) }
        }
    }