cp, _ := controlPlane.Get()
	return cp
}

func (s *DiscoveryServer) findGenerator(typeURL string, con *Connection) model.XdsResourceGenerator {
	if g, f := s.Generators[con.proxy.Metadata.Generator+"/"+typeURL]; f {
		return g
	}
	if g, f := s.Generators[string(con.proxy.Type)+"/"+typeURL]; f {
		return g
	}

	if g, f := s.Generators[typeURL]; f {
		return g
	}

)

// 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 {
	return model.GetMetricType(typeURL)
}

// GetResourceType returns resource form of an abbreviated form
func GetResourceType(shortType string) string {

		return "ECDS"
	case AddressType, WorkloadType:
		return "WDS"
	case WorkloadAuthorizationType:
		return "WADS"
	default:
		return typeURL
	}
}

// GetMetricType returns the form of a type reported for metrics
func GetMetricType(typeURL string) string {
	switch typeURL {
	case ClusterType:
		return "cds"
	case ListenerType:
		return "lds"
	case RouteType:
		return "rds"
	case EndpointType:

			},
			request: &discovery.DiscoveryRequest{
				TypeUrl: model.ClusterType,
			},
			response: true,
		},
		{
			name: "ack",
			proxy: &TestProxy{
				WatchedResources: map[string]*WatchedResource{
					model.ClusterType: {
						NonceSent: "nonce",
					},
				},
			},
			request: &discovery.DiscoveryRequest{
				TypeUrl:       model.ClusterType,
				VersionInfo:   "v1",

		ads.RequestResponseAck(t, &discovery.DiscoveryRequest{TypeUrl: v3.ClusterType})
		ads.RequestResponseAck(t, &discovery.DiscoveryRequest{TypeUrl: v3.ListenerType})
		ads.RequestResponseAck(t, &discovery.DiscoveryRequest{
			TypeUrl:       v3.EndpointType,
			ResourceNames: []string{"outbound|9080||app2.default.svc.cluster.local"},
		})
		ads.RequestResponseAck(t, &discovery.DiscoveryRequest{
			TypeUrl:       v3.RouteType,

		GenericXdsConfigs: []*status.ClientConfig_GenericXdsConfig{
			{
				TypeUrl:      v3.ClusterType,
				ConfigStatus: config.cdsSyncStatus,
			},
			{
				TypeUrl:      v3.ListenerType,
				ConfigStatus: config.ldsSyncStatus,
			},
			{
				TypeUrl:      v3.RouteType,
				ConfigStatus: config.rdsSyncStatus,
			},
			{
				TypeUrl:      v3.EndpointType,
				ConfigStatus: config.edsSyncStatus,
			},
			{

	deleted model.DeletedResources,
	usedDelta bool,
	delta model.ResourceDelta,
	incremental bool,
) {
	current := con.proxy.GetWatchedResource(w.TypeUrl).LastResources
	if current == nil {
		log.Debugf("ADS:%s: resources initialized", v3.GetShortType(w.TypeUrl))
		return
	}
	if deltaRes == nil && deleted == nil && len(sotwRes) == 0 {

	// nolint: staticcheck
	for _, config := range clientConfig.GetXdsConfig() {
		var typeURL string
		switch config.PerXdsConfig.(type) {
		case *xdsstatus.PerXdsConfig_ListenerConfig:
			typeURL = xdsresource.ListenerType
		case *xdsstatus.PerXdsConfig_ClusterConfig:
			typeURL = xdsresource.ClusterType
		case *xdsstatus.PerXdsConfig_RouteConfig:
			typeURL = xdsresource.RouteType
		case *xdsstatus.PerXdsConfig_EndpointConfig:

		name    string
		input   *configdump.Wrapper
		wantErr error
	}{
		{
			name: "Test1",
			input: &configdump.Wrapper{
				ConfigDump: &envoy_admin.ConfigDump{
					Configs: []*anypb.Any{
						{
							TypeUrl: "type.googleapis.com/envoy.admin.v3.ListenersConfigDump",
						},
					},
				},
			},
			wantErr: nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {

		Node:          req.Node,
		TypeUrl:       req.TypeUrl,
		ResponseNonce: req.ResponseNonce,
		ErrorDetail:   &status.Status{Message: "Test request NACK"},
	})
	return resp
}

func (a *DeltaAdsTest) WithID(id string) *DeltaAdsTest {
	a.ID = id
	return a
}

func (a *DeltaAdsTest) WithType(typeURL string) *DeltaAdsTest {
	a.Type = typeURL
	return a
}