func (i *istiodContext) Report(c config.GroupVersionKind, m diag.Message) {
	msgs := i.messages[i.currentAnalyzer]
	if msgs == nil {
		msgs = &diag.Messages{}
		i.messages[i.currentAnalyzer] = msgs
	}
	msgs.Add(m)
}

func (i *istiodContext) SetAnalyzer(analyzerName string) {
	i.currentAnalyzer = analyzerName
}

func (i *istiodContext) GetMessages(analyzerNames ...string) diag.Messages {
	result := diag.Messages{}

		})
	}
	oldmsgs := map[string]diag.Messages{}
	pushFn := func(combinedKinds sets.Set[config.GroupVersionKind]) {
		res, err := c.analyzer.ReAnalyzeSubset(combinedKinds, stop)
		if err != nil {
			log.Errorf("In-cluster analysis has failed: %s", err)
			return
		}
		// reorganize messages to map
		index := map[status.Resource]diag.Messages{}
		for _, m := range res.Messages {

        if !c.Exists(collections.Gateway, resource.NewName(r.Metadata.FullName.Namespace, gwName)) {
            // Messages are defined in galley/pkg/config/analysis/msg/messages.yaml
            // From there, code is generated for each message type, including a constructor function
            // that you can use to create a new validation message of each type.
            msg := msg.NewReferencedResourceNotFound(r, "gateway", gwName)

		return
	}
	messages := make([]cniLog, 0, len(cniLogs))
	for _, l := range cniLogs {
		msg, ok := parseCniLog(l)
		if !ok {
			continue
		}
		messages = append(messages, msg)
	}
	// Lock log message printing to prevent log messages from different CNI
	// processes interleave.
	l.mu.Lock()
	defer l.mu.Unlock()
	for _, m := range messages {
		logger := pluginLog

	return registerScope(DefaultScopeName, "Unscoped logging messages.", 1),
		registerScope(GrpcScopeName, "logs from gRPC", 3)
}

var defaultScope, grpcScope = registerDefaultScopes()

// Fatal outputs a message at fatal level.
func Fatal(fields any) {
	defaultScope.Fatal(fields)
}

// Fatalf uses fmt.Sprintf to construct and log a message at fatal level.
func Fatalf(format string, args ...any) {

	"context"
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"sync"
	"time"

	"go.uber.org/zap/buffer"
	"go.uber.org/zap/zapcore"
)

// An udsCore write entries to an UDS server with HTTP Post. Log messages will be encoded into a JSON array.
type udsCore struct {
	client       http.Client
	minimumLevel zapcore.Level
	url          string
	enc          zapcore.Encoder
	buffers      []*buffer.Buffer

	// nolint
	HttpProtocolOptionsType = "envoy.extensions.upstreams.http.v3.HttpProtocolOptions"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	return model.GetShortType(typeURL)
}

// GetMetricType returns the form of a type reported for metrics
func GetMetricType(typeURL string) string {

			result, err := runAnalyzer(sa)
			if err != nil {
				t.Fatalf("Error running analysis on testcase %s: %v", tc.name, err)
			}

			g.Expect(extractFields(result.Messages)).To(ConsistOf(tc.expected), "%v", prettyPrintMessages(result.Messages))
		})
	}
}

func setupMultiClusterEnvironmentForCase(tc mcTestCase, cr local.CollectionReporterFn) (*local.IstiodAnalyzer, error) {

	sa.AddDefaultResources()
	g.Expect(sa.stores).To(HaveLen(0))
}

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()
}

	istiolog "istio.io/istio/pkg/log"
)

type httpServerErrorLogWriter struct{}

// Webhook http.Server.ErrorLog handler specifically to filter
// http: TLS handshake error from 127.0.0.1:<PORT>: EOF
// messages that occur when clients send RST while TLS handshake is still in progress.
// httpsReadyClient can trigger this periodically when multiple concurrent probes are hitting this endpoint.