return FlattenOperationResult.of(specs.stream().filter(e -> !ignoreSpec.test(e)).collect(toSet()));
    }

    private Stream<ExcludeSpec> maybeFilter(Set<ExcludeSpec> specs, Predicate<ExcludeSpec> ignoreSpec, boolean filtered) {
        Stream<ExcludeSpec> stream = specs.stream();
        if (filtered) {
            stream = stream.filter(e -> !ignoreSpec.test(e));
        }
        return stream;
    }

		add chain ip6 kube-proxy filter-forward { type filter hook forward priority -110 ; }
		add chain ip6 kube-proxy filter-input { type filter hook input priority -110 ; }
		add chain ip6 kube-proxy filter-output { type filter hook output priority -110 ; }
		add chain ip6 kube-proxy filter-output-post-dnat { type filter hook output priority -90 ; }
		add chain ip6 kube-proxy filter-prerouting { type filter hook prerouting priority -110 ; }

 *
 * ```
 * filter(StripJavaComments::class)
 * filter(com.mycompany.project.CustomFilter::class)
 * filter(HeadFilter::class, "lines" to 25, "skip" to 2)
 * filter(ReplaceTokens::class, "tokens" to mapOf("copyright" to "2009", "version" to "2.3.1"))
 * ```
 *
 * @param filterType type of the filter to add
 * @param properties map of filter properties
 * @return this
 */

func TestLabels(t *testing.T) {
	tests := []struct {
		filter   string
		labels   Set
		expected bool
		err      bool
	}{
		{filter: "", labels: nil, expected: true},
		{filter: "", labels: NewSet(Postsubmit), expected: true},
		{filter: "", labels: NewSet(Postsubmit, CustomSetup), expected: true},
		{filter: "$requires.kube", labels: NewSet(Postsubmit, CustomSetup), err: true},

        ScopeArtifactFilter filter = new ScopeArtifactFilter(Artifact.SCOPE_TEST);

        assertTrue(filter.include(newArtifact(Artifact.SCOPE_COMPILE)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_SYSTEM)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_PROVIDED)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_RUNTIME)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_TEST)));

        "tokenizer" : "fess_japanese_normal",
        "filter" : ["reading_form"]
      },
      "reading_term_analyzer" : {
        "type" : "custom",
        "tokenizer" : "fess_japanese_normal"
      },
      "normalize_analyzer" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],
        "filter" : ["lowercase"]
      },
      "contents_analyzer" : {

    This is intended to be used for TF1 (graph mode) tests.

    Args:
      input_shape: Shape of the input tensor.
      filter_shape: Shape of the filter.
      use_variable_for_filter: Setting this to `True` makes the filter for the
        conv operation a `tf.Variable`.

    Returns:
      in_placeholder: Input tensor placeholder.
      output_tensor: The resulting tensor of the convolution operation.

        "tokenizer" : "fess_japanese_normal",
        "filter" : ["reading_form"]
      },
      "reading_term_analyzer" : {
        "type" : "custom",
        "tokenizer" : "fess_japanese_normal"
      },
      "normalize_analyzer" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],
        "filter" : ["lowercase"]
      },
      "contents_analyzer" : {

        "tokenizer" : "fess_japanese_normal",
        "filter" : ["reading_form"]
      },
      "reading_term_analyzer" : {
        "type" : "custom",
        "tokenizer" : "fess_japanese_normal"
      },
      "normalize_analyzer" : {
        "type" : "custom",
        "tokenizer" : "keyword",
        "char_filter" : ["mapping_char"],
        "filter" : ["lowercase"]
      },
      "contents_analyzer" : {

	// If net.Dialer.DualStack (IPv6 "Happy Eyeballs") support is
	// enabled, this may be called multiple times.
	ConnectStart func(network, addr string)

	// ConnectDone is called when a new connection's Dial
	// completes. The provided err indicates whether the
	// connection completed successfully.
	// If net.Dialer.DualStack ("Happy Eyeballs") support is