protected final ElementSource<T> collection;
    protected final CollectionFilter<S> filter;

    public FilteredElementSource(ElementSource<T> collection, CollectionFilter<S> filter) {
        this.collection = collection;
        this.filter = filter;
    }

    @Override
    public boolean add(S o) {

		},
		{
			name:                    "unknown caller",
			caller:                  ztunnelCaller,
			trustedAccounts:         allowZtunnel,
			requestedIdentityString: podSameNode.Identity(),
			pods:                    []pod{podSameNode},
			wantErr:                 "pod istio-system/ztunnel-a not found",
		},
		{
			name: "bad UID",
			caller: func(k security.KubernetesInfo) security.KubernetesInfo {

        def spec = { it < 5 }
        def filter = { Integer[] nums -> filter(nums as List, spec) }

        expect:
        filter(1, 2, 3) == [1, 2, 3]
        filter(7, 8, 9) == []
        filter() == []
        filter(4, 5, 6) == [4]
    }

    def "array filtering"() {
        given:
        def spec = { it < 5 }
        def filter = { Integer[] nums -> filter(nums, spec) }

        expect:

    func.return %mul : tensor<*xf32>
  }

  func.func private @internal_conv3d_fn(
                         %input : tensor<*xf32>, %filter : tensor<*xi8>) -> tensor<*xf32> {

   // Use identity op to avoid the filter being constant-folded.
    %identity = "tf.Identity"(%filter) : (tensor<*xi8>) -> tensor<*xi8>
    %2 = "tf.Cast"(%identity) {Truncate = false} : (tensor<*xi8>) -> tensor<*xf32>
    %3 = "tf.Conv3D"(%input, %2) {

	}
	if b.proxy.SupportsEnvoyExtendedJwt() {
		filter := b.applier.JwtFilter(true, b.proxy.Type != model.SidecarProxy)
		if filter != nil {
			return []*hcm.HttpFilter{filter}
		}
		return nil
	}
	res := []*hcm.HttpFilter{}
	if filter := b.applier.JwtFilter(false, false); filter != nil {
		res = append(res, filter)
	}
	forSidecar := b.proxy.Type == model.SidecarProxy
	if filter := b.applier.AuthNFilter(forSidecar); filter != nil {

          "tokenizer": "standard",
          "filter": [
            "truncate20_filter",
            "lowercase",
            "arabic_stop",
            "arabic_normalization",
            "arabic_keywords",
            "arabic_override",
            "arabic_stemmer"
          ]
        },
        "armenian_analyzer": {
          "tokenizer":  "standard",
          "filter": [
            "truncate20_filter",

        }
        queryCommandMap.put(name, queryCommand);
    }

    public void addFilter(final Filter filter) {
        filterList.add(filter);
        createFilterChain();
    }

    protected void createFilterChain() {
        FilterChain chain = createDefaultFilterChain();
        for (final Filter element : filterList) {
            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;

pkg go/types, method (*Interface) Embedded //deprecated
pkg image, var ZP //deprecated
pkg image, var ZR //deprecated
pkg image/jpeg, type Reader //deprecated
pkg net, type Dialer struct, Cancel //deprecated
pkg net, type Dialer struct, DualStack //deprecated
pkg net/http, method (*Transport) CancelRequest //deprecated
pkg net/http, type CloseNotifier //deprecated
pkg net/http, type ProtocolError //deprecated

    public fun filter(analysisSession: KaSession, annotation: KaAnnotation, owner: KaAnnotated): Boolean

    public infix fun and(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =
        KaRendererAnnotationsFilter filter@{ annotation, owner ->
            val analysisSession = this@filter
            filter(analysisSession, annotation, owner) && other.filter(analysisSession, annotation, owner)
        }

    private class FilteredEventRegister<S extends T> implements CollectionEventRegister<S> {
        private final CollectionFilter<S> filter;
        private final CollectionEventRegister<S> delegate;

        FilteredEventRegister(CollectionFilter<S> filter, CollectionEventRegister<T> delegate) {
            this.filter = filter;
            this.delegate = Cast.uncheckedCast(delegate);
        }

        @Override