/**
 * Adds a content filter to be used during the copy.
 * Multiple calls add additional filters to the filter chain.
 * Each filter should implement [FilterReader].
 * Import `org.apache.tools.ant.filters.*` for access to all the standard Ant filters.
 *
 * Examples:
 *
 * ```
 * filter<StripJavaComments>()
 * filter<com.mycompany.project.CustomFilter>()
 * filter<HeadFilter>("lines" to 25, "skip" to 2)

            }
        }
        return builder.build();
    }

    @Override
    public void addFilter(Spec<? super Task> filter) {
        this.filter = Specs.intersect(this.filter, filter);
    }

    @Override
    public void setContinueOnFailure(boolean continueOnFailure) {
        this.continueOnFailure = continueOnFailure;
    }

    @Override

	// Stats
	filters = extension.PopAppendNetwork(filters, wasm, extensions.PluginPhase_STATS)
	filters = extension.PopAppendNetwork(filters, wasm, extensions.PluginPhase_UNSPECIFIED_PHASE)
	filters = append(filters, buildMetricsNetworkFilters(lb.push, lb.node, class, policySvc)...)

	// Terminal filters
	filters = append(filters, networkFilterStack...)
	return filters
}

        filtered.asList() == ["realized2", "unrealized2"]

        and: "unrealized element get realized"
        container.index.asMap().size() == 4
        container.index.pendingAsMap.size() == 2

        filtered.index.asMap().size() == 2
        filtered.index.pendingAsMap.size() == 1
    }

    def "can get filtered element by index"() {
        given:
        list.addAll(["a", "b", "c"])

    def "removes Groovy internals from stack trace"() {
        def spec = new GroovyStackTraceSpec()
        def filter = new StackTraceFilter(spec)
        def trace = createTrace()

        when:
        def filtered = filter.filter(trace)

        then:
        filtered.size() == 7

     * estimate size instead of the real size is that sometimes the real size is too expensive to compute.
     * Typically in a filtered collection you would have to actually do the filtering before knowing the size,
     * so killing all possible optimizations. Instead, it should return the size of the collection it wraps,

     * <p>Adds a content filter to be used during the copy.  Multiple calls to filter, add additional filters to the
     * filter chain.  Each filter should implement {@code java.io.FilterReader}. Include {@code
     * org.apache.tools.ant.filters.*} for access to all the standard Ant filters.</p>
     *
     * <p> Examples:
     * <pre>
     *    filter(StripJavaComments)
     *    filter(com.mycompany.project.CustomFilter)
     * </pre>
     *

		},

		"no-resources": {
			filter:   filterAny,
			requests: []*resourceapi.NamedResourcesRequest{requestAny},

			expectAllocateErr: true,
		},

		"okay": {
			model:    oneInstance,
			filter:   filterAny,
			requests: []*resourceapi.NamedResourcesRequest{requestAny},

			expectAllocation: []string{instance1},
		},

		"filter-mismatch": {
			model:    oneInstance,

		b.logger.AppendDebugf("built %d HTTP filters for DENY action", len(configs.http))
		filters = append(filters, configs.http...)
	}
	if configs := b.build(b.allowPolicies, rbacpb.RBAC_ALLOW, false); configs != nil {
		b.logger.AppendDebugf("built %d HTTP filters for ALLOW action", len(configs.http))
		filters = append(filters, configs.http...)
	}
	return filters
}

// BuildTCP returns the TCP filters built from the authorization policy.

        container.index.pendingAsMap.size() == 2

        when: "filter the list via the `named` method"
        def filtered = container.named { it.contains("2") }

        then: "unrealized elements remain as such"
        container.index.asMap().size() == 2
        container.index.pendingAsMap.size() == 2

        filtered.index.asMap().size() == 1
        filtered.index.pendingAsMap.size() == 1