b.WriteString("MonitoringPort: " + fmt.Sprint(c.MonitoringPort) + "\n")
	b.WriteString("LogUDSAddress: " + fmt.Sprint(c.LogUDSAddress) + "\n")
	b.WriteString("CNIEventAddress: " + fmt.Sprint(c.CNIEventAddress) + "\n")
	b.WriteString("ZtunnelUDSAddress: " + fmt.Sprint(c.ZtunnelUDSAddress) + "\n")

	b.WriteString("AmbientEnabled: " + fmt.Sprint(c.AmbientEnabled) + "\n")
	b.WriteString("AmbientDNSCapture: " + fmt.Sprint(c.AmbientDNSCapture) + "\n")

type sortTest struct {
	data  any    // Always a map.
	print string // Printed result using our custom printer.
}

var sortTests = []sortTest{
	{
		map[int]string{7: "bar", -3: "foo"},
		"-3:foo 7:bar",
	},
	{
		map[uint8]string{7: "bar", 3: "foo"},
		"3:foo 7:bar",
	},
	{
		map[string]string{"7": "bar", "3": "foo"},
		"3:foo 7:bar",
	},
	{

		if IsTerminal() {
			return color.New(color.FgYellow).SprintfFunc()
		}
		return fmt.Sprintf
	}()

	Green = func() func(a ...interface{}) string {
		if IsTerminal() {
			return color.New(color.FgGreen).SprintFunc()
		}
		return fmt.Sprint
	}()

	Greenf = func() func(format string, a ...interface{}) string {
		if IsTerminal() {
			return color.New(color.FgGreen).SprintfFunc()
		}
		return fmt.Sprintf

	Save              bool
	Builder           string
	SupportsEmulation bool
	NoClobber         bool
	NoCache           bool
	Targets           []string
	Variants          []string
	Architectures     []string
	BaseVersion       string
	BaseImageRegistry string
	ProxyVersion      string
	ZtunnelVersion    string
	IstioVersion      string
	Tags              []string
	Hubs              []string

	if msg == "" {
		fmt.Fprintln(Output, args...)
	} else {
		fmt.Fprintf(Output, msg, args...)
	}
}

type errorMsg struct{}

var errorMessage errorMsg

func (i errorMsg) json(msg string, args ...interface{}) {
	var message string
	if msg != "" {
		message = fmt.Sprintf(msg, args...)
	} else {
		message = fmt.Sprint(args...)
	}
	logJSON, err := json.Marshal(&log.Entry{

					t.Errorf("%v: expect: %v, got %v after time round", utils.FileWithLineNum(), expect.(time.Time), curTime)
				}
			} else if fmt.Sprint(got) != fmt.Sprint(expect) {
				t.Errorf("%v: expect: %#v, got %#v", utils.FileWithLineNum(), expect, got)
			}
		}

		if fmt.Sprint(got) == fmt.Sprint(expect) {
			return
		}

		if reflect.Indirect(reflect.ValueOf(got)).IsValid() != reflect.Indirect(reflect.ValueOf(expect)).IsValid() {

			return nil, err
		}
		c.address = net.JoinHostPort(lb, fmt.Sprint(svc.Spec.Ports[0].Port))
		c.addressVM = net.JoinHostPort(lb, fmt.Sprint(svc.Spec.Ports[1].Port))
	} else {
		c.address = net.JoinHostPort(svc.Spec.ClusterIP, fmt.Sprint(svc.Spec.Ports[0].Port))
		c.addressVM = net.JoinHostPort(svc.Spec.ClusterIP, fmt.Sprint(svc.Spec.Ports[1].Port))
	}

	for _, tt := range tests {
		got := itoa.Itoa(tt)
		want := fmt.Sprint(tt)
		if want != got {
			t.Fatalf("Itoa(%d) = %s, want %s", tt, got, want)
		}
	}
}

func TestUitoa(t *testing.T) {
	tests := []uint{0, 1, 100, 999, math.MaxUint32, uint(maxUint64)}
	for _, tt := range tests {
		got := itoa.Uitoa(tt)
		want := fmt.Sprint(tt)
		if want != got {
			t.Fatalf("Uitoa(%d) = %s, want %s", tt, got, want)
		}

	{ET_LOOS + 5, "ET_LOOS+5"},
	{ProgFlag(0x50), "0x50"},
	{COMPRESS_ZLIB + 2, "COMPRESS_ZSTD+1"},
}

func TestNames(t *testing.T) {
	for i, tt := range nameTests {
		s := fmt.Sprint(tt.val)
		if s != tt.str {
			t.Errorf("#%d: Sprint(%d) = %q, want %q", i, tt.val, s, tt.str)
		}
	}

func copyStringInterfaceMap(m map[string]any) map[string]any {
	out := make(map[string]any, len(m))
	for k, v := range m {
		out[k] = v
	}
	return out
}

func maybeSprintf(format string, args []any) string {
	msg := format
	if len(args) > 0 {
		msg = fmt.Sprintf(format, args...)
	}
	return msg