return err
	}
	return c.RouteDiff()
}

// nonstrictResolver is an AnyResolver that ignores unknown proto messages
type nonstrictResolver struct{}

var envoyResolver nonstrictResolver

func (m *nonstrictResolver) Resolve(typeURL string) (legacyproto.Message, error) {
	// See https://github.com/golang/protobuf/issues/747#issuecomment-437463120
	mname := typeURL

		return StatusTrue
	default:
		return StatusFalse
	}
}

// WrappedStatus provides a wrapper around a status message that keeps track of whether or not any
// changes have been made. This allows users to declarative write status, without worrying about
// tracking changes. When read to commit (typically to Kubernetes), any messages with Dirty=false can
// be discarded.
type WrappedStatus struct {
	// Status is the object that is wrapped.

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

	"istio.io/istio/cni/pkg/nodeagent"
)

// newCNIClient is a unit test override variable for mocking.
var newCNIClient = buildClient

// An udsCore write entries to an UDS server with HTTP Post. Log messages will be encoded into a JSON array.
type CNIEventClient struct {
	client *http.Client
	url    string
}

func buildClient(address, path string) CNIEventClient {
	c := &http.Client{
		Transport: &http.Transport{

	WorkloadAuthorizationType = APITypePrefix + "istio.security.Authorization"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	switch typeURL {
	case ClusterType:
		return "CDS"
	case ListenerType:
		return "LDS"
	case RouteType:
		return "RDS"
	case EndpointType:
		return "EDS"

			if IsDeprecatedError(e) {
				return true
			}
		}
	}

	return false
}

func (de *DeprecatedError) Error() string {
	return de.msg
}

// FindDeprecatedMessagesInEnvoyLog looks for deprecated messages in the `logs` parameter. If found, it will return
// a DeprecatedError. Use `extraInfo` to pass additional info, like pod namespace/name, etc.
func FindDeprecatedMessagesInEnvoyLog(logs, extraInfo string) error {

			}
		}

		// If AuthzPolicy is mesh-wide and selectorless,
		// no need to keep the analysis
		return
	}

	// If the AuthzPolicy is namespace-wide and there are present Pods,
	// no messages should be triggered.
	if ap.GetSelector() == nil {
		if len(podLabelsMap[apNs]) == 0 {
			c.Report(gvk.AuthorizationPolicy, msg.NewNoMatchingWorkloadsFound(r, ""))
		}
		return
	}

)

const (
	LikelyCauseFirstPrefix  = "The likely cause is "
	LikelyCauseSecondPrefix = "Another possible cause could be "
)

// General boilerplate.
const (
	// Boilerplate messages applicable all over the code base.

	// Action
	actionIfErrPersistsCheckBugList            = "If this error persists, " + actionCheckBugList

	assert.Equal(t, m.Payload.(*zdsapi.WorkloadRequest_Add).Add.Uid, uid)
	// send ack so the server doesn't wait for us.
	sendAck(ztunClient)

	// second message should be the snap sent message
	m, fds = readRequest(t, ztunClient)
	assert.Equal(t, len(fds), 0)

	sent := m.Payload.(*zdsapi.WorkloadRequest_SnapshotSent).SnapshotSent
	if sent == nil {
		panic("expected snapshot sent")
	}

		w.sidecar = nil
	}
	return err
}

func (w *workload) checkDeprecation() error {
	logs, err := w.sidecar.Logs()
	if err != nil {
		return fmt.Errorf("could not get sidecar logs to inspect for deprecation messages: %v", err)
	}

	info := fmt.Sprintf("pod: %s/%s", w.pod.Namespace, w.pod.Name)
	return errors.FindDeprecatedMessagesInEnvoyLog(logs, info)