@Test
public void shouldBimapLeft() {
final Either<Integer, String> actual =
Either.<Integer, String>left(1).bimap(i -> i + 1, s -> s + "1");
final Either<Integer, String> expected = Either.left(2);
assertThat(actual).isEqualTo(expected);
}
@Test
public void shouldPeekOnLeftProjectionOfLeft() {
final List<Integer> actual = new ArrayList<>();
final Either<Integer, String> testee =
Either.<Integer, String>left(1).left().peek(actual::add).toEither();
assertThat(actual).isEqualTo(Collections.singletonList(1));
assertThat(testee).isEqualTo(Either.left(1));
}
@Test
public void shouldPeekOnRightProjectionOfLeft() {
final List<Integer> actual = new ArrayList<>();
final Either<String, Integer> testee =
Either.<String, Integer>left("1").right().peek(actual::add).toEither();
assertThat(actual.isEmpty()).isTrue();
assertThat(testee).isEqualTo(Either.<String, Integer>left("1"));
}
@Test
public void shouldFlatMapRightProjectionOfLeftOnRightProjectionOfRight() {
final Either<String, String> good = Either.right("good");
final Either<String, String> bad = Either.left("bad");
final RightProjection<String, Tuple2<String, String>> actual =
good.right().flatMap(g -> bad.right().map(b -> Tuple.of(g, b)));
assertThat(actual.toEither()).isEqualTo(Either.left("bad"));
}
@Test
public void shouldFlatMapOnLeftProjectionOfLeft() {
final Either<Integer, String> actual =
Either.<Integer, String>left(1)
.left()
.flatMap(i -> Either.<Integer, String>left(i + 1).left())
.toEither();
assertThat(actual).isEqualTo(Either.left(2));
}
@Test
public void shouldFlatMapOnRightProjectionOfLeft() {
final Either<String, Integer> actual =
Either.<String, Integer>left("1")
.right()
.flatMap(i -> Either.<String, Integer>right(i + 1).right())
.toEither();
assertThat(actual).isEqualTo(Either.left("1"));
}
@Test
public void left_A$() throws Exception {
Either<String, Integer> target = Left.apply("foo");
Option<String> actual = target.left();
assertThat(actual.isDefined(), is(true));
assertThat(actual.getOrNull(), is(equalTo("foo")));
}
@Test
public void transformingNothingYieldsLeft() {
final Function<Optional<O>, Either<O, O>> maybeToEither =
new OptionalToEither<O, O>(new ConstantSupplier<O>(O.ANOTHER));
final Either<O, O> got = maybeToEither.apply(Optional.<O>empty());
Assert.assertEquals(Either.left(O.ANOTHER), got);
}
@Test
public void shouldReturnOtherWhenOrElseRunOnRightProjectionOfLeft() {
final boolean[] actual = new boolean[] {false};
Either.<String, Integer>left("1")
.right()
.orElseRun(
s -> {
actual[0] = true;
});
assertThat(actual[0]).isTrue();
}
@SuppressWarnings("unchecked")
@Test
public void left() throws Exception {
new Random()
.ints(20, 0, 2)
.mapToObj(
i ->
i == 0
? Either.<String, Integer>left("left value (String)")
: Either.<String, Integer>right(42))
.forEach(
either ->
either.apply(
left -> System.out.println("received left value: " + left.substring(11)),
right ->
System.out.println(
"received right value: 0x" + Integer.toHexString(right))));
}
@Test
public void shouldConvertRightProjectionOfLeftToString() {
assertThat(Either.left(1).right().toString()).isEqualTo("RightProjection(Left(1))");
}
@Test
public void shouldHashRightProjectionOfLeft() {
assertThat(Either.left(1).right().hashCode()).isEqualTo(Objects.hashCode(Either.left(1)));
}
@Test
public void shouldEqualRightProjectionOfLeft() {
assertThat(Either.left(1).right()).isEqualTo(Either.left(1).right());
}
@Test
public void shouldNotEqualRightProjectionOfLeftIfObjectIsOfDifferentType() {
assertThat(Either.left(1).right().equals(new Object())).isFalse();
}
@Test
public void shouldFilterNoneOnRightProjectionOfLeftIfPredicateNotMatches() {
final boolean actual =
Either.<String, Integer>left("1").right().filter(i -> false).toOption().isDefined();
assertThat(actual).isFalse();
}
@Test
public void shouldReturnFalseWhenCallingIsRightOnLeft() {
assertThat(Either.left(1).isRight()).isFalse();
}
@Test(expected = RuntimeException.class)
public void shouldThrowWhenOrElseThrowWithFunctionOnRightProjectionOfLeft() {
Either.<String, Integer>left("1")
.right()
.orElseThrow(i -> new RuntimeException(String.valueOf(i)));
}
@Test
public void shouldForEachOnRightProjectionOfLeft() {
final List<Integer> actual = new ArrayList<>();
Either.<String, Integer>left("1").right().forEach(actual::add);
assertThat(actual.isEmpty()).isTrue();
}
@Test
public void shouldConvertRightProjectionOfLeftToNone() {
assertThat(Either.left(0).right().toOption()).isEqualTo(Option.none());
}
@Test
public void shouldNotEqualLeftIfObjectIsNull() {
assertThat(Either.left(1).equals(null)).isFalse();
}
@Test
public void shouldConvertRightProjectionOfLeftToEither() {
final Either<Integer, String> self = Either.left(1);
assertThat(self.right().toEither()).isEqualTo(self);
}
@Test
public void shouldConvertRightProjectionOfLeftToJavaOptional() {
assertThat(Either.left(0).right().toJavaOptional()).isEqualTo(Optional.empty());
}
@Test
public void shouldHashLeft() {
assertThat(Either.left(1).hashCode()).isEqualTo(Objects.hashCode(1));
}
@Test
public void shouldEqualLeft() {
assertThat(Either.left(1)).isEqualTo(Either.left(1));
}
@Test
public void shouldConvertLeftToString() {
assertThat(Either.left(1).toString()).isEqualTo("Left(1)");
}
@Test
public void shouldEqualRightProjectionOfLeftIfObjectIsSame() {
final RightProjection<?, ?> r = Either.left(1).right();
assertThat(r.equals(r)).isTrue();
}
public <T> Either<T, E> either(Supplier<T> nothing) {
if (hasValue) {
return Either.right(element);
}
return Either.left(nothing.get());
}
@Test
public void shouldNotEqualRightProjectionOfLeftIfObjectIsNull() {
assertThat(Either.left(1).right().equals(null)).isFalse();
}
@Test
public void shouldReturnIteratorOfLeftOfRightProjection() {
assertThat((Iterator<Object>) Either.left(1).right().iterator()).isNotNull();
}
@Test
public void shouldEqualLeftIfObjectIsSame() {
final Either<Integer, ?> left = Either.left(1);
assertThat(left.equals(left)).isTrue();
}
