Assert Anzahl der passenden Elemente in der Sammlung über Hamcrest

Question

Ich habe eine Sammlung von Matcher wie List<Matcher<?>> filters und einige Sammlung von Elementen List<Element> elementsToCheck. Ich möchte eine Behauptung schaffen, wenn es überprüft sind x Elemente, die alle Filter, so etwas wie das Spiel:

public void checkMatch(List<Matcher<?>> filters, int expectedSize){   
    MatcherAssert.assertThat(elementsToCheck, ???);  
} 

ich so etwas geschrieben:

final Iterator<Element> iterator = this.elements.iterator(); 
final List<Element> filtered = new ArrayList<>(); 
while (iterator.hasNext()) { 
    final Element element = iterator.next(); 
    boolean allMatches = true; 
    for (final Matcher<?> matcher : this.filters) { 
     if (!matcher.matches(element)) { 
      allMatches = false; 
      break; 
     } 
    } 

    if (allMatches) { 
     filtered.add(element); 
    } 
} 

MatcherAssert.assertThat(filtered, 
Matchers.hasSize(this.expectedSize)); 

Gibt es eine bessere Lösung?

Answer 1

Wenn ich Aufgabe richtig understodd: Liste elementsToCheck- Sammlung von Elementen

this.filters - Sammlung von Matchers

elementsToCheck.stream()           
       .filter(element ->!this.filters.stream() 
           .filter(matcher -> matcher.matches(element))      
    .collect(Collectors.toList()).size() == this.filters.size()) 
    .collect(Collectors.toList()).size() == this.expectedSize 

Answer 2

org.hamcrest.CoreMatchers.allOf Matcher kann anstelle der Liste der Matcher verwendet werden. Dann kann ein Test wie folgt aussehen (I Testliste von Strings als Beispiel):

// given 
Matcher<String> allOfMatcher = allOf(containsString("a"), containsString("b")); 
long expectedNumberOfMatches = 2L; 

// when 
List<String> elementsToCheck = Arrays.asList("aa", "ab", "ba", "bb"); // substitute with some actual method call 

// then 
assertThat(elementsToCheck, notNullValue()); 
assertThat(elementsToCheck.stream().filter(allOfMatcher::matches).collect(Collectors.counting()), equalTo(expectedNumberOfMatches)); 

Sie auch die bereits bestehende Liste der Matcher zu überladener Version von allOf passieren kann, der Iterable als Argument.

private Matcher<Element> getAllOfMatcher(List<Matcher<? super Element>> matchers) { 
    return CoreMatchers.allOf(matchers); 
}