func TestIssue56509(t *testing.T) {
	// The directory testdata/bads contains a .s file that has an unparsable
	// comment. (go/build parses initial comments in non-go files looking for
	// //go:build or //+go build comments).
	p, err := ImportDir("testdata/bads", 0)
	if err == nil {
		t.Fatalf("could not import testdata/bads: %v", err)
	}

	if len(p.InvalidGoFiles) != 0 {

	// For example: type is for Any is 'type.googlepis.com/istio.networking.v1alpha3.EnvoyFilter
	// We use: networking.istio.io/v1alpha3/EnvoyFilter
	kind := strings.SplitN(w.TypeUrl, "/", 3)
	if len(kind) != 3 {
		log.Warnf("ADS: Unknown watched resources %s", w.TypeUrl)
		// Still return an empty response - to not break waiting code. It is fine to not know about some resource.
		return resp, model.DefaultXdsLogDetails, nil
	}

    TFTensorType:$fallback_tensor
  );

  let results = (outs
    TensorType:$dht
  );

  let assemblyFormat = "operands attr-dict `:` type($dht)";
}

// TODO(rohitju): This is Ads specific, need to find an appropriate home for it.
def SetSparseMatrixResourceOp : FallbackSync_Op<"set_sparse_matrix_resource", [CoreRT_TypedAttributeTrait]> {
  let summary = "Set a Sparse matrix in resource array";

		}
	})
}

func (a *AdsTest) adsReceiveChannel() {
	context.AfterFunc(a.context, a.Cleanup)
	for {
		resp, err := a.client.Recv()
		if err != nil {
			if isUnexpectedError(err) {
				log.Warnf("ads received error: %v", err)
			}
			select {
			case a.error <- err:
			case <-a.context.Done():
			}
			return
		}
		select {
		case a.responses <- resp:
		case <-a.context.Done():
			return

		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(defaultClientMaxReceiveMessageSize)),
	}
}

// ADSC implements a basic client for ADS, for use in stress tests and tools
// or libraries that need to connect to Istio pilot or other ADS servers.
type ADSC struct {
	// Stream is the GRPC connection stream, allowing direct GRPC send operations.
	// Set after Dial is called.

		}
	})
}

func (a *DeltaAdsTest) adsReceiveChannel() {
	context.AfterFunc(a.context, a.Cleanup)
	for {
		resp, err := a.client.Recv()
		if err != nil {
			if isUnexpectedError(err) {
				log.Warnf("ads received error: %v", err)
			}
			select {
			case a.error <- err:
			case <-a.context.Done():
			}
			return
		}
		select {
		case a.responses <- resp:
		case <-a.context.Done():
			return

	for _, l := range listenerDump.DynamicListeners {
		if l.ActiveState != nil && l.ActiveState.Listener != nil {
			listenerTyped := &listener.Listener{}
			// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
			l.ActiveState.Listener.TypeUrl = v3.ListenerType
			err = l.ActiveState.Listener.UnmarshalTo(listenerTyped)
			if err != nil {
				return nil, fmt.Errorf("unmarshal listener: %v", err)

                     }
                  ]
               },
               {
                  "matcher": {
                     "id": "byName",
                     "options": "wads"
                  },
                  "properties": [
                     {
                        "id": "displayName",
                        "value": "Authorization"
                     }

	EnvoyJwtFilterName = "envoy.filters.http.jwt_authn"
)

var SDSAdsConfig = &core.ConfigSource{
	ConfigSourceSpecifier: &core.ConfigSource_Ads{
		Ads: &core.AggregatedConfigSource{},
	},
	// We intentionally do *not* set InitialFetchTimeout to 0s here, as this is used for
	// credentialName SDS which may refer to secrets which do not exist. We do not want to block the

   * needed again; and for short-lived ones, it does not matter.
   */

  /**
   * Padded variant of AtomicLong supporting only raw accesses plus CAS. The value field is placed
   * between pads, hoping that the JVM doesn't reorder them.
   *
   * <p>JVM intrinsics note: It would be possible to use a release-only form of CAS here, if it were
   * provided.
   */
  static final class Cell {