Java 类org.hamcrest.collection.IsEmptyIterable 实例源码

项目：uri-toolkit 文件：StructuredPathTest.java

@Test
public void testIterator() throws Exception
{
    assertThat(new StructuredPath(), new IsEmptyIterable());
    assertThat(new StructuredPath(IdempotentEncoded.EMPTY), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY));
    assertThat(new StructuredPath(IdempotentEncoded.CURRENT), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT));
    assertThat(new StructuredPath(IdempotentEncoded.PARENT), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT));
    assertThat(new StructuredPath(IdempotentEncoded.PARENT, IdempotentEncoded.PARENT),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT));
    assertThat(new StructuredPath(IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b")),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b")));
    assertThat(new StructuredPath(IdempotentEncoded.CURRENT, new Encoded("a"), new Encoded("b")),
            Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, new Encoded("a"), new Encoded("b")));
    assertThat(new StructuredPath(IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b")),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b")));
}

项目：java-mammoth 文件：XmlParserTests.java

private Matcher<Iterable<XmlNode>> isNodes(List<Matcher<? extends XmlNode>> children) {
    if (children.isEmpty()) {
        return (Matcher)new IsEmptyIterable<>();
    } else {
        return new IsIterableContainingInOrder<>((List) children);
    }
}

项目：spring-data-solr 文件：FieldWithQueryParametersTests.java

@Test
public void testAddQueryParameter() {
    field.addQueryParameter(OPTION_WITH_STRING);
    Assert.assertTrue(field.hasQueryParameters());
    Assert.assertThat(field.getQueryParameters(), IsNot.not(IsEmptyCollection.empty()));
    Assert.assertThat(field, IsNot.not(IsEmptyIterable.emptyIterable()));
    Assert.assertEquals(OPTION_WITH_STRING, field.getQueryParameter(OPTION_WITH_STRING.getName()));
}

项目：uri-toolkit 文件：ExtendedTest.java

@Test
public void iterator() throws Exception
{
    assertThat(new Extended(EmptyPath.INSTANCE, EmptyPath.INSTANCE), new IsEmptyIterable<UriEncoded>());
    assertThat(new Extended(EmptyPath.INSTANCE, new EncodedPath(new Precoded("/"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY));
    assertThat(new Extended(new EncodedPath(new Precoded("/")), EmptyPath.INSTANCE),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, IdempotentEncoded.EMPTY));

    assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("./c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("/")), new EncodedPath(new Precoded("../c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("./c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a")), new EncodedPath(new Precoded("../c"))), Matchers.contains((UriEncoded) new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("./c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("/a")), new EncodedPath(new Precoded("../c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("./c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c")));
    assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../../."))),
            Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY));
    assertThat(new Extended(new EncodedPath(new Precoded("a/b")), new EncodedPath(new Precoded("../../.."))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY));

    assertThat(new Extended(new StructuredPath(new Encoded("a"), new Encoded("b")), IdempotentEncoded.CURRENT, new Encoded("c")),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c")));
    assertThat(new Extended(new StructuredPath(new Encoded("a"), new Encoded("b")), IdempotentEncoded.PARENT, new Encoded("c")),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("c")));
}

项目：uri-toolkit 文件：NormalizedTest.java

@Test
public void testIterator() throws Exception
{
    assertThat(new Normalized(EmptyPath.INSTANCE), new IsEmptyIterable());
    assertThat(new Normalized(new EncodedPath(new Precoded("."))), Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded(".."))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("/"))), Matchers.contains((UriEncoded) new Encoded(""), new Encoded("")));
    assertThat(new Normalized(new EncodedPath(new Precoded("/a"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a")));
    assertThat(new Normalized(new EncodedPath(new Precoded("/a/"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("/a/b"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("a"))), Matchers.contains((UriEncoded) new Encoded("a")));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/"))), Matchers.contains((UriEncoded) new Encoded("a"), IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b"))), Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b")));

    assertThat(new Normalized(new EncodedPath(new Precoded("/../a/b"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("a"), new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("/../a/../b"))), Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("../a/b"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("a"), new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("../a/../b"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("/../../a/../b/"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("b"), IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("../../c"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, new Encoded("c")));
    assertThat(new Normalized(new EncodedPath(new Precoded("/../../c/"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.EMPTY, new Encoded("c"), IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("./a/b/./././c"))),
            Matchers.contains((UriEncoded) new Encoded("a"), new Encoded("b"), new Encoded("c")));

    assertThat(new Normalized(new EncodedPath(new Precoded("a/../b"))), Matchers.contains((UriEncoded) new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../.."))),
            Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.CURRENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../.."))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../../"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY));
    assertThat(new Normalized(new EncodedPath(new Precoded("a/b/../../../c"))), Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, new Encoded("c")));
    assertThat(new Normalized(new EncodedPath(new Precoded("../a/../../b"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("./a/./../b"))), Matchers.contains((UriEncoded) new Encoded("b")));
    assertThat(new Normalized(new EncodedPath(new Precoded("../a/../../b/../"))),
            Matchers.contains((UriEncoded) IdempotentEncoded.PARENT, IdempotentEncoded.PARENT, IdempotentEncoded.EMPTY));
}

项目：spring-data-solr 文件：FieldWithQueryParametersTests.java

@Test
public void testGetIteratorWhenNoneAvailable() {
    Assert.assertThat(field, IsEmptyIterable.emptyIterable());
}

项目：faststring 文件：TestUtilities.java

public static <E extends Comparable<E>> void assertListEmpty(Iterable<E> actual) {
    assertThat(actual, IsEmptyIterable.emptyIterable());
}