}
	if strings.HasSuffix(exp, "*") {
		return strings.HasPrefix(ns, strings.TrimSuffix(exp, "*"))
	}

	return strings.EqualFold(ns, exp)
}

// Build a map indexed by namespace with in-mesh Pod's labels
func initPodLabelsMap(c analysis.Context) map[string][]klabels.Set {
	podLabelsMap := make(map[string][]klabels.Set)

	c.ForEach(gvk.Pod, func(r *resource.Instance) bool {

		horizBarChar = "-"
		vertBarChar = "|"
	}

	lines := []string{
		color.YellowBold(topLeftChar + strings.Repeat(horizBarChar, maxContentWidth) + topRightChar),
		color.YellowBold(vertBarChar) + line1InColor + strings.Repeat(" ", maxContentWidth-line1Length) + color.YellowBold(vertBarChar),
		color.YellowBold(vertBarChar) + line2InColor + strings.Repeat(" ", maxContentWidth-line2Length) + color.YellowBold(vertBarChar),

}

// mode computes the mode for the given file name.
func mode(name string, _ fs.FileMode) fs.FileMode {
	if strings.HasPrefix(name, "bin/") ||
		strings.HasPrefix(name, "pkg/tool/") ||
		strings.HasSuffix(name, ".bash") ||
		strings.HasSuffix(name, ".sh") ||
		strings.HasSuffix(name, ".pl") ||
		strings.HasSuffix(name, ".rc") {
		return 0o755
	} else if ok, _ := amatch("**/go_?*_?*_exec", name); ok {

`
	m := CommentMap(strings.NewReader(src), regexp.MustCompile("^ ERROR "))
	found := 0 // number of errors found
	for line, errlist := range m {
		for _, err := range errlist {
			if err.Pos.Line() != line {
				t.Errorf("%v: got map line %d; want %d", err, err.Pos.Line(), line)
				continue
			}
			// err.Pos.Line() == line

			got := strings.TrimSpace(err.Msg[len(" ERROR "):])

// file path on Windows.
func QuoteGlob(s string) string {
	if !strings.ContainsAny(s, `*?[]`) {
		return s
	}
	var sb strings.Builder
	for _, c := range s {
		switch c {
		case '*', '?', '[', ']':
			sb.WriteByte('\\')
		}
		sb.WriteRune(c)
	}
	return sb.String()

)

type execTestCase struct {
	args     []string
	revision string
	noIstiod bool

	// Typically use one of the three
	expectedOutput string // Expected constant output
	expectedString string // String output is expected to contain

	wantException bool
}

func TestInternalDebug(t *testing.T) {
	cases := []execTestCase{
		{ // case 0, no args
			args:           []string{},
			noIstiod:       true,

		t.Fatalf("want %q, got (uncanonicalized) %q", want.String(), gotFull)
	}
}

func TestDebugLogWraparound(t *testing.T) {
	skipDebugLog(t)

	// Make sure we don't switch logs so it's easier to fill one up.
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	runtime.ResetDebugLog()
	var longString = strings.Repeat("a", 128)
	var want strings.Builder

// Forwarded headers (in that order).
func GetSourceScheme(r *http.Request) string {
	var scheme string

	// Retrieve the scheme from X-Forwarded-Proto.
	if proto := r.Header.Get(xForwardedProto); proto != "" {
		scheme = strings.ToLower(proto)
	} else if proto = r.Header.Get(xForwardedScheme); proto != "" {
		scheme = strings.ToLower(proto)
	} else if proto := r.Header.Get(forwarded); proto != "" {

		})
	}
}

func checkCoroTestProgOutput(t *testing.T, output string) {
	t.Helper()

	c := strings.SplitN(output, "\n", 2)
	if len(c) == 1 {
		t.Fatalf("expected at least one complete line in the output, got:\n%s", output)
	}
	expect, ok := strings.CutPrefix(c[0], "expect: ")
	if !ok {
		t.Fatalf("expected first line of output to start with \"expect: \", got: %q", c[0])
	}

	}
	return strings.Join(withoutPort, ", ")
}

func unexpandDomains(domains []string) []string {
	unique := sets.New(domains...)
	shouldDelete := sets.New[string]()
	for _, h := range domains {
		stripFull := strings.TrimSuffix(h, ".svc.cluster.local")
		if unique.Contains(stripFull) && stripFull != h {
			shouldDelete.Insert(h)
		}
		stripPartial := strings.TrimSuffix(h, ".svc")