String simple = "a,b,c";
    List<String> letters = COMMA_SPLITTER.splitToList(simple);
    assertThat(letters).containsExactly("a", "b", "c").inOrder();
  }

  public void testCharacterSimpleSplitToStream() {
    String simple = "a,b,c";
    List<String> letters = COMMA_SPLITTER.splitToStream(simple).collect(toImmutableList());
    assertThat(letters).containsExactly("a", "b", "c").inOrder();
  }

/**
 * Apply multiple filters.
 *
 */
public class AndArtifactFilter implements ArtifactFilter {
    private Set<ArtifactFilter> filters;

    public AndArtifactFilter() {
        this.filters = new LinkedHashSet<>();
    }

    public AndArtifactFilter(List<ArtifactFilter> filters) {
        this.filters = new LinkedHashSet<>(filters);
    }

    public boolean include(Artifact artifact) {

                    };
                    filters.add(new PredicateVersionFilter(predicate));
                } else {
                    throw new IllegalArgumentException("Unsupported filter expression: " + expression);
                }
            }
        }
        if (filters.isEmpty()) {
            return null;
        } else if (filters.size() == 1) {
            return filters.get(0);
        } else {

      SortedSet<E> set = delegate.create(allEntries.toArray());

      return createSubSet(set, firstExclusive, lastExclusive);
    }

    /** Calls the smallest subSet overload that filters out the extreme values. */
    SortedSet<E> createSubSet(SortedSet<E> set, E firstExclusive, E lastExclusive) {
      if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
        return set.headSet(lastExclusive);

    /**
     * Creates a new filter that combines the specified filters.
     *
     * @param filters The filters to combine, may be {@code null}.
     */
    public CumulativeScopeArtifactFilter(CumulativeScopeArtifactFilter... filters) {
        this.scopes = new HashSet<>();

        if (filters != null) {
            for (CumulativeScopeArtifactFilter filter : filters) {
                addScopes(filter.getScopes());
            }

              ],
              "listener_filters": [
                {
                  "name": "envoy.filters.listener.original_dst",
                  "typed_config": {
                    "@type": "type.googleapis.com/envoy.extensions.filters.listener.original_dst.v3.OriginalDst"
                  }
                },
                {
                  "name": "envoy.filters.listener.http_inspector",

    String simple = "a,b,c";
    Iterable<String> letters = Splitter.on('.').split(simple);
    assertThat(letters).containsExactly("a,b,c").inOrder();
  }

  public void testCharacterSplitWithDoubleDelimiter() {
    String doubled = "a,,b,c";
    Iterable<String> letters = COMMA_SPLITTER.split(doubled);
    assertThat(letters).containsExactly("a", "", "b", "c").inOrder();
  }

istio.io/telemetry/stats/prometheus/sidecar/Outbound/TCP      
default.display-metadata                                      envoy.extensions.filters.http.wasm.v3.Wasm

/**
 * Apply multiple filters, accepting an artifact if at least one of the filters accepts it.
 *
 */
@Deprecated
public class OrArtifactFilter implements ArtifactFilter {

    private Set<ArtifactFilter> filters;

    public OrArtifactFilter() {
        this.filters = new LinkedHashSet<>();
    }

    public OrArtifactFilter(Collection<ArtifactFilter> filters) {

              ],
              "listener_filters": [
                {
                  "name": "envoy.filters.listener.original_dst",
                  "typed_config": {
                    "@type": "type.googleapis.com/envoy.extensions.filters.listener.original_dst.v3.OriginalDst"
                  }
                },
                {
                  "name": "envoy.filters.listener.http_inspector",