ExclusionArtifactFilter filter = new ExclusionArtifactFilter(Collections.singletonList(exclusion));

        assertThat(filter.include(artifact), is(true));
    }

    @Test
    void testExcludeGroupIdWildcard() {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId("*");
        exclusion.setArtifactId("maven-core");

        assertFalse(filter(createUnfiltered(contents), EVEN).contains(new Object()));
      }
    }

    public void testAddAllFailsAtomically() {
      ImmutableList<Integer> toAdd = ImmutableList.of(2, 4, 3);
      for (List<Integer> contents : SAMPLE_INPUTS) {
        C filtered = filter(createUnfiltered(contents), EVEN);
        C filteredToModify = filter(createUnfiltered(contents), EVEN);

            return;
        }
        String filter = subRoleSet.stream().map(s -> String.format(groupFilter, s)).collect(Collectors.joining());
        if (subRoleSet.size() > 1) {
            filter = "(|" + filter + ")";
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Group Filter: {}", filter);
        }
        search(bindDn, filter, null, () -> ldapUser.getEnvironment(), result -> {

                    Map<String, String> map = Maps.newHashMap();
                    putEntries(map, entries);
                    map.putAll(ENTRIES_TO_FILTER);
                    map = Maps.filterEntries(map, FILTER_ENTRIES_1);
                    return Maps.filterEntries(map, FILTER_ENTRIES_2);
                  }
                })
            .named("Maps.filterEntries[Maps.filterEntries[Map, Predicate], Predicate]")

    private final ResourceFilter filter;
    private final SmbResource parent;
    private SmbResource next;


    /**
     * @param parent
     * @param delegate
     * @param filter
     * 
     */
    public FileEntryAdapterIterator ( SmbResource parent, CloseableIterator<FileEntry> delegate, ResourceFilter filter ) {
        this.parent = parent;
        this.delegate = delegate;

    private final Iterator<FileEntry> delegate;
    private final ResourceFilter filter;
    private final SmbResource parent;
    private SmbResource next;


    /**
     * @param parent
     * @param delegate
     * @param filter
     * 
     */
    public ShareEnumIterator ( SmbResource parent, Iterator<FileEntry> delegate, ResourceFilter filter ) {
        this.parent = parent;
        this.delegate = delegate;

        return true;
    }

    /**
     * Returns a filtered list of classpath elements. This method is invoked when the caller
     * requested that all dependencies are placed on the classpath, with no module-path element.
     *
     * @param scopeFilter a filter returning {@code true} for the artifact scopes to accept.
     * @param includeTestDir whether to include the test directory in the classpath elements.

     * @param wildcard
     * @param searchAttributes
     * @param filter
     * @throws CIFSException
     * 
     */
    public NetServerEnumIterator ( SmbFile parent, SmbTreeHandleImpl th, String wildcard, int searchAttributes, ResourceNameFilter filter )
            throws CIFSException {
        this.parent = parent;
        this.nameFilter = filter;
        SmbResourceLocator locator = parent.getLocator();

import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ResolutionListener;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver;

/**
 * Artifact collector - takes a set of original artifacts and resolves all of the best versions to use

  }

  private static final Predicate<Entry<Integer, String>> FILTER_GET_PREDICATE =
      new Predicate<Entry<Integer, String>>() {
        @Override
        public boolean apply(Entry<Integer, String> entry) {
          return !"badvalue".equals(entry.getValue()) && 55556 != entry.getKey();
        }
      };

  private static final Predicate<Entry<String, Integer>> FILTER_KEYSET_PREDICATE =
      new Predicate<Entry<String, Integer>>() {