g := NewWithT(t)

	firstMsg := NewMessage(
		NewMessageType(Error, "B1", "Template: %q"),
		MockResource("B"),
		"B",
	)
	secondMsg := NewMessage(
		NewMessageType(Warning, "A1", "Template: %q"),
		MockResource("B"),
		"B",
	)
	thirdMsg := NewMessage(
		NewMessageType(Warning, "B1", "Template: %q"),
		MockResource("A"),
		"B",
	)
	fourthMsg := NewMessage(
		NewMessageType(Warning, "B1", "Template: %q"),

func NewInternalError(r *resource.Instance, detail string) diag.Message {
	return diag.NewMessage(
		InternalError,
		r,
		detail,
	)
}

// NewDeprecated returns a new diag.Message based on Deprecated.
func NewDeprecated(r *resource.Instance, detail string) diag.Message {
	return diag.NewMessage(
		Deprecated,
		r,
		detail,
	)
}

	"istio.io/istio/pkg/url"
)

func TestFormatter_PrintLog(t *testing.T) {
	g := NewWithT(t)

	firstMsg := diag.NewMessage(
		diag.NewMessageType(diag.Error, "B1", "Explosion accident: %v"),
		diag.MockResource("SoapBubble"),
		"the bubble is too big",
	)
	secondMsg := diag.NewMessage(
		diag.NewMessageType(diag.Warning, "C1", "Collapse danger: %v"),
		diag.MockResource("GrandCastle"),
		"the castle is too old",
	)

	mt := NewMessageType(Error, "IST-0042", "Cheese type not found: %q")
	m := NewMessage(mt, nil, "Feta")

	g.Expect(m.String()).To(Equal(`Error [IST-0042] Cheese type not found: "Feta"`))
}

func TestMessageWithResource_String(t *testing.T) {
	g := NewWithT(t)
	mt := NewMessageType(Error, "IST-0042", "Cheese type not found: %q")

	"istio.io/istio/pkg/config/analysis/diag"
)

func TestErrorOnIssuesFound(t *testing.T) {
	g := NewWithT(t)

	msgs := []diag.Message{
		diag.NewMessage(
			diag.NewMessageType(diag.Error, "B1", "Template: %q"),
			nil,
			"",
		),
		diag.NewMessage(
			diag.NewMessageType(diag.Warning, "A1", "Template: %q"),
			nil,
			"",
		),
	}

	err := errorIfMessagesExceedThreshold(msgs)

func NewMessageType(level Level, code, template string) *MessageType {
	return &MessageType{
		level:    level,
		code:     code,
		template: template,
	}
}

// NewMessage returns a new Message instance from an existing type.
func NewMessage(mt *MessageType, r *resource.Instance, p ...any) Message {
	return Message{
		Type:       mt,
		Resource:   r,
		Parameters: p,
	}
}

	}
}

{{range .Messages}}
// New{{.Name}} returns a new diag.Message based on {{.Name}}.
func New{{.Name}}(r *resource.Instance{{range .Args}}, {{.Name}} {{.Type}}{{end}}) diag.Message {
	return diag.NewMessage(
		{{.Name}},
		r,
		{{- range .Args}}
			{{.Name}},
		{{- end}}
	)
}
{{end}}
`

func generate(m *messages) (string, error) {
	t := template.Must(template.New("code").Parse(tmpl))

	if err != nil {
		return 0
	}
	var ri *resource.Instance
	if resourceIsNil {
		ri = nil
	} else {
		err = f.GenerateStruct(ri)
		if err != nil {
			return 0
		}
	}
	m := diag.NewMessage(mt, ri, parameter)
	_ = m.Unstructured(true)
	_ = m.UnstructuredAnalysisMessageBase()
	_ = m.Origin()
	_, _ = m.MarshalJSON()
	_ = m.String()
	replStr, err := f.GetString()
	if err == nil {

func TestEmptyContext(t *testing.T) {
	fakeType := diag.NewMessageType(diag.Warning, "IST9999", "Fake message for testing")

	ctx := istiodContext{
		messages: map[string]*diag.Messages{
			"full": {
				diag.NewMessage(fakeType, nil),
			},
			"empty": {},
		},
	}
	ctx.GetMessages()
}

func tempFileFromString(t *testing.T, content string) *os.File {
	t.Helper()
	tmpfile, err := os.CreateTemp("", "")

				Reason:             "newReason",
				Message:            "newMessage",
			},
			expectedPatchRequests:    1,
			expectedPatchDataPattern: `{"status":{"conditions":\[{"lastProbeTime":"2020-05-13T01:01:01Z","lastTransitionTime":".*","message":"newMessage","reason":"newReason","status":"newStatus","type":"newType"}]}}`,
		},
		{