func TestStringer(t *testing.T) {
	s := &myStringer{3}
	b := new(strings.Builder)
	tmpl := Must(New("x").Parse("{{.}}"))
	if err := tmpl.Execute(b, s); err != nil {
		t.Fatal(err)
	}
	var expect = "string=3"
	if b.String() != expect {
		t.Errorf("expected %q got %q", expect, b.String())
	}
	e := &errorer{7}
	b.Reset()
	if err := tmpl.Execute(b, e); err != nil {
		t.Fatal(err)
	}
	expect = "error=7"

	}

	return result
}

func (envTopic) Activate(context fw.TopicContext) {
	tmpl := assets.ParseTemplate(context.Layout(), "templates/env.html")

	_ = context.HTMLRouter().StrictSlash(true).NewRoute().Path("/").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		fw.RenderHTML(w, tmpl, getVars())
	})

	return "mem"
}

func (memTopic) Activate(context fw.TopicContext) {
	tmpl := assets.ParseTemplate(context.Layout(), "templates/mem.html")

	_ = context.HTMLRouter().StrictSlash(true).NewRoute().Path("/").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		ms := &runtime.MemStats{}
		runtime.ReadMemStats(ms)
		fw.RenderHTML(w, tmpl, ms)
	})

			"break": func(in any) any { return in },
		}
		tmpl, err := New("").Parse(inp, "", "", make(map[string]*Tree), funcsWithKeywordFunc)
		if err != nil || tmpl == nil {
			t.Errorf("with break func: unexpected error: %v", err)
		}
	}

	{
		// No function called 'break'; treat it as a keyword. Results in a parse
		// error.
		tmpl, err := New("").Parse(inp, "", "", make(map[string]*Tree), make(map[string]any))

	"istio.io/istio/pkg/test/env"
	"istio.io/istio/pkg/test/framework/components/cluster"
	"istio.io/istio/pkg/test/scopes"
	"istio.io/istio/pkg/test/util/retry"
	"istio.io/istio/pkg/test/util/tmpl"
)

const (
	eastWestIngressIstioNameLabel = "eastwestgateway"
	eastWestIngressIstioLabel     = "istio=" + eastWestIngressIstioNameLabel
	eastWestIngressServiceName    = "istio-" + eastWestIngressIstioNameLabel
)

		return nil, err
	}

	tpl, err := tmpl.Parse(raw)
	if err != nil {
		return nil, err
	}
	return param.Parse(tpl), nil
}

func (s sourceImpl) TemplateOrFail(t test.Failer) *param.Template {
	t.Helper()
	tpl, err := s.Template()
	if err != nil {
		t.Fatal(err)
	}
	return tpl
}

func (s sourceImpl) MustTemplate() *param.Template {
	tpl, err := s.Template()
	if err != nil {

	return &pi
}

func (procTopic) Activate(context fw.TopicContext) {
	tmpl := assets.ParseTemplate(context.Layout(), "templates/proc.html")

	_ = context.HTMLRouter().StrictSlash(true).NewRoute().Path("/").HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		fw.RenderHTML(w, tmpl, getProcInfo())
	})

	"istio.io/istio/pkg/test/framework/components/jwt"
	"istio.io/istio/pkg/test/framework/components/namespace"
	"istio.io/istio/pkg/test/framework/label"
	"istio.io/istio/pkg/test/framework/resource"
	"istio.io/istio/pkg/test/util/tmpl"
	"istio.io/istio/tests/integration/security/util/cert"
)

var (
	ist       istio.Instance
	apps      deployment.SingleNamespaceView
	jwtServer jwt.Server
	echoNS    namespace.Instance

	}

	funcMap := template.FuncMap{
		"include": include,
		"indent":  indent,
		"trim":    trim,
	}

	tmpl, err := template.New("").Funcs(funcMap).Parse(buf.String())
	if err != nil {
		return fmt.Errorf("parsing input as text template: %v", err)
	}

	if err := tmpl.Execute(out, data); err != nil {
		return fmt.Errorf("generating result: %v", err)
	}
	return nil
}

		//  t, err := New(name).Funcs(xxx).ParseFiles(name)
		// works. Otherwise we create a new template associated with t.
		var tmpl *Template
		if t == nil {
			t = New(name)
		}
		if name == t.Name() {
			tmpl = t
		} else {
			tmpl = t.New(name)
		}
		_, err = tmpl.Parse(s)
		if err != nil {
			return nil, err
		}
	}
	return t, nil
}