@Test public void fn4Delegate() { Integer[] source = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8 }; Function<Tuple4<Integer, Integer, Integer, Integer>, Tuple4> invert = t4 -> new Tuple4<>(t4.getT4(), t4.getT3(), t4.getT2(), t4.getT1()); Tuple4 tuple = Tuples.fn4(invert).apply(source); assertThat(tuple.getT1()).isEqualTo(4); assertThat(tuple.getT2()).isEqualTo(3); assertThat(tuple.getT3()).isEqualTo(2); assertThat(tuple.getT4()).isEqualTo(1); assertThat((Object) tuple).isExactlyInstanceOf(Tuple4.class); }
@Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (!(o instanceof Tuple5)) return false; if (!super.equals(o)) return false; @SuppressWarnings("rawtypes") Tuple5 tuple5 = (Tuple5) o; return t5.equals(tuple5.t5); }
/** * Create a {@link Tuple4} with the given objects. * * @param t1 The first value in the tuple. Not null. * @param t2 The second value in the tuple. Not null. * @param t3 The third value in the tuple. Not null. * @param t4 The fourth value in the tuple. Not null. * @param <T1> The type of the first value. * @param <T2> The type of the second value. * @param <T3> The type of the third value. * @param <T4> The type of the fourth value. * @return The new {@link Tuple4}. */ public static <T1, T2, T3, T4> Tuple4<T1, T2, T3, T4> of(T1 t1, T2 t2, T3 t3, T4 t4) { return new Tuple4<>(t1, t2, t3, t4); }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + t5.hashCode(); return result; }
@Test public void getTooLargeIndex() { assertThat(full.get(10)).isNull(); }
/** * Map the 4th part (T4) of this {@link Tuple4} into a different value and type, * keeping the other parts. * * @param mapper the mapping {@link Function} for the T4 part * @param <R> the new type for the T4 part * @return a new {@link Tuple4} with a different T4 value */ public <R> Tuple4<T1, T2, T3, R> mapT4(Function<T4, R> mapper) { return new Tuple4<>(t1, t2, t3, mapper.apply(t4)); }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + t5.hashCode(); return result; }
@Test public void getNegativeIndex() { assertThat(full.get(-1)).isNull(); }
@Test public void fn4() { Integer[] source = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8 }; Tuple4<Object, Object, Object, Object> tuple = Tuples.fn4().apply(source); assertThat(tuple.getT1()).isEqualTo(1); assertThat(tuple.getT2()).isEqualTo(2); assertThat(tuple.getT3()).isEqualTo(3); assertThat(tuple.getT4()).isEqualTo(4); assertThat(tuple) .isInstanceOf(Tuple8.class) .containsExactly(1, 2, 3, 4, 5, 6, 7, 8); }
/** * Map the 2nd part (T2) of this {@link Tuple4} into a different value and type, * keeping the other parts. * * @param mapper the mapping {@link Function} for the T2 part * @param <R> the new type for the T2 part * @return a new {@link Tuple4} with a different T2 value */ public <R> Tuple4<T1, R, T3, T4> mapT2(Function<T2, R> mapper) { return new Tuple4<>(t1, mapper.apply(t2), t3, t4); }
@Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (!(o instanceof Tuple5)) return false; if (!super.equals(o)) return false; @SuppressWarnings("rawtypes") Tuple5 tuple5 = (Tuple5) o; return t5.equals(tuple5.t5); }
@Test public void whenDelayMonoJust4() { MonoProcessor<Tuple4<Integer, Integer, Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zipDelayError(Mono.just(1), Mono.just(2), Mono.just(3), Mono.just(4)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2 && v.getT3() == 3 && v.getT4() == 4).isTrue()) .verifyComplete(); }
/** * Map the 3rd part (T3) of this {@link Tuple4} into a different value and type, * keeping the other parts. * * @param mapper the mapping {@link Function} for the T3 part * @param <R> the new type for the T3 part * @return a new {@link Tuple4} with a different T3 value */ public <R> Tuple4<T1, T2, R, T4> mapT3(Function<T3, R> mapper) { return new Tuple4<>(t1, t2, mapper.apply(t3), t4); }
@Test public void whenMonoJust4() { MonoProcessor<Tuple4<Integer, Integer, Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zip(Mono.just(1), Mono.just(2), Mono.just(3), Mono.just(4)) .subscribeWith(mp)) .then(() -> assertThat(mp.isError()).isFalse()) .then(() -> assertThat(mp.isSuccess()).isTrue()) .then(() -> assertThat(mp.isTerminated()).isTrue()) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2 && v.getT3() == 3 && v.getT4() == 4).isTrue()) .verifyComplete(); }