org.cactoos.list.ListOf Java Examples

@Test
public void extractHeadersFromDict() {
    final List<Kvp> kvps = new ListOf<>(
        new Headers.Of(
            new HashDict(
                new KvpOf("test", "test"),
                new KvpOf("h.kfirst", "first"),
                new KvpOf("h.ksecond", "second")
            )
        )
    );
    MatcherAssert.assertThat(
        kvps.size(),
        new IsEqual<>(2)
    );
    MatcherAssert.assertThat(
        kvps.get(0).key(),
        new IsEqual<>("kfirst")
    );
    MatcherAssert.assertThat(
        kvps.get(1).key(),
        new IsEqual<>("ksecond")
    );
}
 

/**
 * FbStatus can react to Condition.
 * @throws Exception If some problem inside
 */
@Test
public void reactsToCondition() throws Exception {
    final RqFallback req = new RqFallback.Fake(
        HttpURLConnection.HTTP_MOVED_PERM
    );
    MatcherAssert.assertThat(
        new RsPrint(
            new FbStatus(
                new Filtered<>(
                    status -> {
                        return status == HttpURLConnection.HTTP_MOVED_PERM
                            || status == HttpURLConnection.HTTP_MOVED_TEMP;
                    },
                    new ListOf<>(
                        HttpURLConnection.HTTP_MOVED_PERM,
                        HttpURLConnection.HTTP_MOVED_TEMP
                    )
                ),
                new FbFixed(new RsText("response text"))
            ).route(req).get()
        ).printBody(),
        Matchers.startsWith("response")
    );
}
 

@Test
public void worksInThreads() {
    new Assertion<>(
        "must work well in multiple threads",
        scalar -> {
            new Assertion<>(
                "must compute value once",
                scalar,
                new ScalarHasValue<>(scalar.value())
            ).affirm();
            return true;
        },
        new RunsInThreads<>(
            new Unchecked<>(
                new Solid<>(() -> new ListOf<>(1, 2))
            )
        )
    ).affirm();
}
 

@Test
public void mustSortIntegerArrayAsSetInAscendingOrder() {
    new Assertion<>(
        "Must keep unique integer numbers sorted",
        new Sorted<>(
            Integer::compareTo,
            2, 1, 3, 2, 1
        ),
        new IsIterableContainingInOrder<>(
            new ListOf<Matcher<? super Integer>>(
                new IsEqual<>(1),
                new IsEqual<>(2),
                new IsEqual<>(3)
            )
        )
    ).affirm();
}
 

@Test
public void mustSortTextIterableAsSetUsingCustomCOmparator() {
    new Assertion<>(
        "Must keep unique integer numbers sorted in descending order",
        new Sorted<>(
            (first, second) -> {
                final String left = new UncheckedText(first).asString();
                final String right = new UncheckedText(second).asString();
                return left.compareTo(right);
            },
            new TextOf("cd"),
            new TextOf("ab"),
            new TextOf("gh"),
            new TextOf("ef")
        ),
        new IsIterableContainingInOrder<>(
            new ListOf<Matcher<? super Text>>(
                new IsEqual<>(new TextOf("ab")),
                new IsEqual<>(new TextOf("cd")),
                new IsEqual<>(new TextOf("ef")),
                new IsEqual<>(new TextOf("gh"))
            )
        )
    ).affirm();
}
 

@Test
public void mustNotBeEqualToSortedSet() {
    new Assertion<>(
        "Sorted set must not be equal to the tested collection",
        new Sorted<>(
            Integer::compareTo,
            2, 1, 3, 2, 1
        ),
        new IsNot<>(
            new IsIterableContainingInOrder<>(
                new ListOf<Matcher<? super Integer>>(
                    new IsEqual<>(1),
                    new IsEqual<>(3),
                    new IsEqual<>(2)
                )
            ))
    ).affirm();
}
 

/**
 * Tests the bug described in #577.
 *
 * @throws Exception If there is some error inside
 */
@Test
@Ignore("See puzzle above")
public void contentDispositionShouldBeRecognized() throws Exception {
    new RqMtFake(
        new RqFake(),
        new RqWithHeader(
            new RqFake(new ListOf<>(""), ""),
            new FormattedText(
                RqMtFakeTest.CONTENT_DISP, "name=\"field1\""
            ).asString()
        ),
        new RqWithHeader(
            new RqFake("", "", "field2Value"),
            new FormattedText(
                RqMtFakeTest.CONTENT_DISP, "name=\"field2\""
            ).asString()
        )
    );
}
 

@Test
public void containsContentInRequestBody() throws IOException {
    final String content = "My name is neo!";
    MatcherAssert.assertThat(
        "Can't add a body to servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake(
                        new ListOf<>(RqFromTest.EOL),
                        content
                    )
                )
            )
        ).printBody(),
        new StringContains(content)
    );
}
 

/**
 * Ctor.
 * @param check Check
 * @param fallback Fallback
 */
@SuppressWarnings
    (
        {
            "PMD.CallSuperInConstructor",
            "PMD.ConstructorOnlyInitializesOrCallOtherConstructors"
        }
    )
public FbStatus(final Iterable<Integer> check,
    final Scalar<Fallback> fallback) {
    super(
        new Fallback() {
            @Override
            public Opt<Response> route(final RqFallback req)
                throws Exception {
                Opt<Response> rsp = new Opt.Empty<>();
                if (new ListOf<>(check).contains(req.code())) {
                    rsp = fallback.get().route(req);
                }
                return rsp;
            }
        }
    );
}
 

@Test
@SuppressWarnings("unchecked")
public void partitionedOne() {
    MatcherAssert.assertThat(
        "Can't generate a Partitioned of partition size 1.",
        new ArrayList<>(
            new ListOf<>(
                new Partitioned<>(1, new ListOf<>(1, 2, 3).iterator())
            )
        ),
        Matchers.equalTo(
            new ListOf<>(
                Collections.singletonList(1), Collections.singletonList(2),
                Collections.singletonList(3)
            )
        )
    );
}
 

/**
 * Ctor.
 * @param threads The quantity of threads which will be used within the
 *  {@link ExecutorService}.
 * @param tasks The tasks to be executed concurrently.
 * @param timeout The maximum time to wait.
 * @param unit The time unit of the timeout argument.
 * @checkstyle IndentationCheck (20 lines)
 * @checkstyle ParameterNumberCheck (5 lines)
 */
public Timed(
    final int threads,
    final Iterable<Scalar<T>> tasks,
    final long timeout,
    final TimeUnit unit
) {
    this(
        todo -> {
            final ExecutorService executor = Executors.newFixedThreadPool(
                threads
            );
            try {
                return executor.invokeAll(new ListOf<>(todo), timeout, unit);
            } finally {
                executor.shutdown();
            }
        },
        tasks
    );
}
 

@Test
public void takesDefaultContentType() {
    MatcherAssert.assertThat(
        new HtContentType(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "",
                        "Hello, dude!"
                    )
                )
            )
        ).value(),
        new IsEqual<>(new ListOf<>("application/octet-stream"))
    );
}
 

@Test
public final void testIntegerFibonacciRange() {
    MatcherAssert.assertThat(
        "Can't generate a range of fibonacci integers",
        new ListOf<>(
            new RangeOf<>(
                1,
                100,
                new Func<Integer, Integer>() {
                    private int last;
                    @Override
                    public Integer apply(
                        final Integer input) throws Exception {
                        final int next = this.last + input;
                        this.last = input;
                        return next;
                    }
                }
            )
        ),
        Matchers.contains(1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89)
    );
}
 

@Test
@SuppressWarnings("unchecked")
public void partitionedLastPartitionSmaller() {
    new Assertion<>(
        "Can't generate a Partitioned of size 2 last partition smaller.",
        new ListOf<>(
            new Partitioned<>(2, new ListOf<>(1, 2, 3).iterator())
        ),
        new IsEqual<>(
            new ListOf<>(
                new ListOf<>(1, 2),
                new ListOf<>(3)
            )
        )
    ).affirm();
}
 

@Test
public void canBeConstructedFromText() throws Exception {
    final Iterator<Byte> itr = new IteratorOfBytes(
        new TextOf("ABC")
    );
    new Assertion<>(
        "Must have 3 elements",
        new ListOf<>(
            itr.next(),
            itr.next(),
            itr.next(),
            itr.hasNext()
        ),
        new HasValues<Object>(
            (byte) 'A', (byte) 'B', (byte) 'C', false
        )
    ).affirm();
}
 

@SuppressWarnings("unchecked")
@Test
public void containsAllHeadersNames() {
    MatcherAssert.assertThat(
        "Can't get the header names",
        Collections.list(
            new HttpServletRequestFake(
                new RqWithHeaders(
                    new RqFake(),
                    "AnyHeader: anyValue",
                    "CrazyHeader: crazyValue"
                )
            ).getHeaderNames()
        ),
        new IsIterableContainingInAnyOrder<>(
            new ListOf<>(
                new IsEqual<>("host"),
                new IsEqual<>("crazyheader"),
                new IsEqual<>("anyheader")
            )
        )
    );
}
 

@Test
public void reversesIterator() {
    new Assertion<>(
        "Must reverse the iterator",
        new ListOf<>(
            new Reversed<>(
                new IteratorOf<>("c", "a", "c", "t", "o", "o", "s")
            )
        ),
        new IsEqual<>(
            new ListOf<>(
                new IteratorOf<>("s", "o", "o", "t", "c", "a", "c")
            )
        )
    ).affirm();
}
 

@Test
public void toArray() {
    new Assertion<>(
        "toArray() must be equals to original",
        new Immutable<>(
            new ListOf<>(1, 2)
        ).toArray(),
        new IsEqual<>(
            new ListOf<>(1, 2).toArray()
        )
    ).affirm();
}
 

@Test
public void string() {
    MatcherAssert.assertThat(
        "Can't convert to string",
        new Mapped<Integer, Integer>(
            x -> x * 2,
            new ListOf<>(1, 2, 3)
        ).toString(),
        Matchers.equalTo("2, 4, 6")
    );
}
 

@Test
public void containsHostHeaderInHeader() throws IOException {
    final String method = "GET /one-more-test";
    final String header = "Host: www.thesite.com";
    MatcherAssert.assertThat(
        "Can't set a host in a servlet request",
        new RqPrint(
            new RqFrom(
                new HttpServletRequestFake(
                    new RqFake(
                        new ListOf<>(
                            method,
                            header
                        ),
                        ""
                    )
                )
            )
        ).printHead(),
        new StringStartsWith(
            new Joined(
                RqFromTest.EOL,
                method,
                header,
                RqFromTest.LOCAL_ADDRESS,
                RqFromTest.REMOTE_ADDRESS
            ).asString()
        )
    );
}
 

@Test
public void testToString() {
    new Assertion<>(
        "toString() must be equals to original",
        new Immutable<>(
            new ListOf<>(1, 2, 3)
        ).toString(),
        new IsEqual<>(
            new ListOf<>(1, 2, 3).toString()
        )
    ).affirm();
}
 

@Test
public void contains() {
    new Assertion<>(
        "contains() must be equals to original",
        new Immutable<>(
            new ListOf<>(1, 2)
        ).contains(1),
        new IsEqual<>(
            new ListOf<>(1, 2).contains(1)
        )
    ).affirm();
}
 

@Test
public void retainAll() {
    new Assertion<>(
        "retainAll() must throw exception",
        () -> new Immutable<>(
            new ListOf<>(1, 2, 3)
        ).retainAll(new ListOf<>(1)),
        new Throws<>(
            new MatcherOf<>(
                (String msg) -> msg.equals("#retainAll(): the collection is read-only")
            ),
            UnsupportedOperationException.class
        )
    ).affirm();
}
 

/**
 * Ctor.
 * @param prms List of Param
 */
public ParamsNamed(final Param... prms) {
    this.prms = new Unchecked<>(
        new Sticky<>(
            () -> new ListOf<>(prms)
        )
    );
}
 

@Test
public void add() {
    new Assertion<>(
        "add() must throw exception",
        () -> new Immutable<>(
            new ListOf<>(1, 2)
        ).add(3),
        new Throws<>(
            new MatcherOf<>(
                (String msg) -> msg.equals("#add(): the collection is read-only")
            ),
            UnsupportedOperationException.class
        )
    ).affirm();
}
 

@Test
public void removeAll() {
    new Assertion<>(
        "removeAll() must throw exception",
        () -> new Immutable<>(
            new ListOf<>(1, 2, 3)
        ).removeAll(new ListOf<>(2, 3)),
        new Throws<>(
            new MatcherOf<>(
                (String msg) -> msg.equals("#removeAll(): the collection is read-only")
            ),
            UnsupportedOperationException.class
        )
    ).affirm();
}
 

@Test
public void testToArray() {
    new Assertion<>(
        "toArray(T[]) must be equals to original",
        new Immutable<>(
            new ListOf<>(1, 2, 3)
        ).toArray(new Integer[3]),
        new IsEqual<>(
            new ListOf<>(1, 2, 3).toArray(new Integer[3])
        )
    ).affirm();
}
 

@Test
public void addAll() {
    new Assertion<>(
        "addAll() must throw exception",
        () -> new Immutable<>(
            new ListOf<>(1, 2)
        ).addAll(new ListOf<>(3, 4)),
        new Throws<>(
            new MatcherOf<>(
                (String msg) -> msg.equals("#addAll(): the collection is read-only")
            ),
            UnsupportedOperationException.class
        )
    ).affirm();
}
 

@Test
public void containsAll() {
    final ListOf<Integer> another = new ListOf<>(3, 4, 5);
    new Assertion<>(
        "containsAll() must be equals to original",
        new Immutable<>(
            new ListOf<>(1, 2, 3)
        ).containsAll(another),
        new IsEqual<>(
            new ListOf<>(1, 2, 3).containsAll(another)
        )
    ).affirm();
}
 

@Test
@SuppressWarnings("unchecked")
public void calculatesDisjointSets() throws Exception {
    final Node one = new Node.Simple("one");
    final Node two = new Node.Simple("two");
    final Node three = new Node.Simple("three");
    final Node four = new Node.Simple("four");
    final Node five = new Node.Simple("five");
    final Node six = new Node.Simple("six");
    one.connections().add(two);
    two.connections().addAll(new ListOf<>(one, three));
    three.connections().add(two);
    four.connections().add(five);
    five.connections().add(four);
    final Graph graph = new FakeGraph(
        new ListOf<>(one, two, three, four, five, six)
    );
    // @checkstyle MagicNumberCheck (50 lines)
    new Assertion<>(
        "Must build disjoint sets correctly",
        new Disjoint(graph).value(),
        new AllOf<Iterable<Set<Node>>>(
            new ListOf<>(
                new HasValuesMatching<>(
                    set -> set.contains(one) && set.contains(two) && set.contains(three)
                        && set.size() == 3
                ),
                new HasValuesMatching<>(
                    set -> set.contains(five) && set.contains(four) && set.size() == 2
                ),
                new HasValuesMatching<>(
                    set -> set.contains(six) && set.size() == 1
                )
            )
        )
    ).affirm();
}