您如何断言 `Collection`s 的`Collection` 包含包含某些元素的元素？

Question

假设我有 Strings "foo"、"bar" 和 baz

我收到了Stream<String[]> candidates。

我现在想 assertThatcandidates 中的所有元素都是包含 {"foo", "bar"}（任意顺序）或 {"bar", "baz"}（任意顺序）的元组。

我怎样才能最好地做到这一点？

Answer 1

您可以使用allMatch 或allSatisfy 之类的东西

assertThat(candidates).allMatch(candidate -> candidate.contains...)

或

assertThat(candidates).allSatisfy(
          candidate -> assertThat(candidate).satisfiesAnyOf(
                       c -> {      
                          c.contains("foo");
                          c.contains("bar");
                       },
                       c -> {      
                          c.contains("bar");
                          c.contains("baz");
                       })                                     
         );

Answer 2

为简单起见，我将创建一个可以验证元组的函数。将对流中的每个元素调用此函数。我还将创建第二个函数，它可以检查一个数组是否包含另一个数组的每个元素。像这样的：

import org.junit.Test;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;

public class MyTest {

    @Test
    public void test(){
        Stream<String[]> stream = Stream.of(new String[]{"foo", "bar"}, new String[]{"bar", "baz"});
        stream.forEach(arr -> assertThat(validTuple(arr)).isTrue());

        //Order does not matter:
        stream = Stream.of(new String[]{"bar", "foo"}, new String[]{"baz", "bar"});
        stream.forEach(arr -> assertThat(validTuple(arr)).isTrue());

        //Invalid tuples
        stream = Stream.of(new String[]{"foo", "asdf"}, new String[]{"foo", "baz"});
        stream.forEach(arr -> assertThat(validTuple(arr)).isFalse());
    }

    private boolean validTuple(String[] array){
        if(array.length != 2) return false;
        return containsAll(array, "foo", "bar") || containsAll(array, "bar", "baz");
    }

    private boolean containsAll(String[] array, String... values){
        for (String value : values) {
            boolean containsValue = false;
            for (String s : array) {
                if(s.equals(value)){
                    containsValue = true;
                    break;
                }
            }
            if(!containsValue){
                return false;
            }
        }

        return true;
    }

}

您现在可以轻松地将这些方法提取到一个专用类中，以便在需要时在其他测试中重复使用它们。

Answer 3

第一步是使用Stream#allMatch(Predicate) 检查元组中[foo, bar] 或 [bar, baz] 和元组大小的组合。

在第二步中，我已将内部数组转换为 Set<String>，这样可以轻松解决 [foo, foo] 之类的情况，因为重复项将被删除，而且我们可以使用 Set.contains() 进行 O(1) 查找检查[foo, bar] 或 [bar, baz] 是否存在于元组流中：

class TupleTest {

@org.junit.jupiter.api.Test
void testTupleOfCandidates_True() {
    Stream<String[]> candidates = Stream.of(new String[]{"bar", "foo"}, new String[]{"bar", "baz"});
    assertTrue(isCandidateStreamValid(candidates));

    candidates = Stream.of(new String[]{"bar", "foo"}, new String[]{"bar", "baz"});
    assertTrue(isCandidateStreamValid(candidates));

}

@org.junit.jupiter.api.Test
void testTupleOfCandidates_False() {
    Stream<String[]> candidates = Stream.of(new String[]{"foo", "foo"}, new String[]{"bar", "baz"});
    assertFalse(isCandidateStreamValid(candidates));

    candidates = Stream.of(new String[]{"bar", "foo"}, new String[]{"bar", "baz"}, new String[]{"baz", "bar"});
    assertTrue(isCandidateStreamValid(candidates));
}

public boolean isCandidateStreamValid(Stream<String[]> candidates){
        return candidates.allMatch(arr -> {
            Set<String> data = new HashSet(Arrays.asList(arr));
            return data.size() == 2
                    &&
                    ((data.contains("foo") && data.contains("bar"))
                            ||
                            (data.contains("bar") && data.contains("baz")));
        });
    }
}