@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(); }