@Test public void fn7Delegate() { Integer[] source = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8 }; Function<Tuple7<Integer, Integer, Integer, Integer, Integer, Integer, Integer>, Tuple7> invert = t7 -> new Tuple7<>(t7.getT7(), t7.getT6(), t7.getT5(), t7.getT4(), t7.getT3(), t7.getT2(), t7.getT1()); Tuple7 tuple = Tuples.fn7(invert).apply(source); assertThat(tuple.getT1()).isEqualTo(7); assertThat(tuple.getT2()).isEqualTo(6); assertThat(tuple.getT3()).isEqualTo(5); assertThat(tuple.getT4()).isEqualTo(4); assertThat(tuple.getT5()).isEqualTo(3); assertThat(tuple.getT6()).isEqualTo(2); assertThat(tuple.getT7()).isEqualTo(1); assertThat((Object) tuple).isExactlyInstanceOf(Tuple7.class); } @Test
@Test public void sanityTestHashcode() { Tuple7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> same = new Tuple7<>(1, 2, 3, 4, 5, 6, 7); Tuple7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> different = new Tuple7<>(1, 2, 3, 4, 5, 6,1); assertThat(full.hashCode()) .isEqualTo(same.hashCode()) .isNotEqualTo(different.hashCode()); } }
@Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (!(o instanceof Tuple8)) return false; if (!super.equals(o)) return false; @SuppressWarnings("rawtypes") Tuple8 tuple8 = (Tuple8) o; return t8.equals(tuple8.t8); }
@Test public void mapT3() { Tuple7<Integer, Integer, String, Integer, Integer, Integer, Integer> base = Tuples.of(100, 200, "Foo", 400, 500, 600, 700); Tuple2<?,?> mapped = base.mapT3(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), base.getT2(), 3, base.getT4(), base.getT5(), base.getT6(), base.getT7()); }
@Test public void mapT1() { Tuple7<String, Integer, Integer, Integer, Integer, Integer, Integer> base = Tuples.of("Foo", 200, 300, 400, 500, 600, 700); Tuple2<?,?> mapped = base.mapT1(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(3, base.getT2(), base.getT3(), base.getT4(), base.getT5(), base.getT6(), base.getT7()); }
@Test public void mapT2() { Tuple7<Integer, String, Integer, Integer, Integer, Integer, Integer> base = Tuples.of(100, "Foo", 300, 400, 500, 600, 700); Tuple2<?,?> mapped = base.mapT2(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), 3, base.getT3(), base.getT4(), base.getT5(), base.getT6(), base.getT7()); }
@Test public void mapT4() { Tuple7<Integer, Integer, Integer, String, Integer, Integer, Integer> base = Tuples.of(100, 200, 300, "Foo", 500, 600, 700); Tuple2<?,?> mapped = base.mapT4(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), base.getT2(), base.getT3(), 3, base.getT5(), base.getT6(), base.getT7()); }
@Test public void mapT6() { Tuple7<Integer, Integer, Integer, Integer, Integer, String, Integer> base = Tuples.of(100, 200, 300, 400, 500, "Foo", 700); Tuple2<?,?> mapped = base.mapT6(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), base.getT2(), base.getT3(), base.getT4(), base.getT5(), 3, base.getT7()); }
@Test public void mapT7() { Tuple7<Integer, Integer, Integer, Integer, Integer, Integer, String> base = Tuples.of(100, 200, 300, 400, 500, 600, "Foo"); Tuple2<?,?> mapped = base.mapT7(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), base.getT2(), base.getT3(), base.getT4(), base.getT5(), base.getT6(), 3); }
@Test public void mapT5() { Tuple7<Integer, Integer, Integer, Integer, String, Integer, Integer> base = Tuples.of(100, 200, 300, 400, "Foo", 600, 700); Tuple2<?,?> mapped = base.mapT5(String::length); assertThat(mapped).isNotSameAs(base) .hasSize(7) .containsExactly(base.getT1(), base.getT2(), base.getT3(), base.getT4(), 3, base.getT6(), base.getT7()); }
/** * Map the 4th part (T4) of this {@link Tuple7} 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 Tuple7} with a different T4 value */ public <R> Tuple7<T1, T2, T3, R, T5, T6, T7> mapT4(Function<T4, R> mapper) { return new Tuple7<>(t1, t2, t3, mapper.apply(t4), t5, t6, t7); }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + t8.hashCode(); return result; }
/** * Map the 2nd part (T2) of this {@link Tuple7} 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 Tuple7} with a different T2 value */ public <R> Tuple7<T1, R, T3, T4, T5, T6, T7> mapT2(Function<T2, R> mapper) { return new Tuple7<>(t1, mapper.apply(t2), t3, t4, t5, t6, t7); }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + t8.hashCode(); return result; }
@Test public void whenMonoJust7() { StepVerifier.create(Mono.zip(Mono.just(1), Mono.just(2), Mono.just(3), Mono.just(4), Mono.just(5), Mono.just(6), Mono.just(7))) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2 && v.getT3() == 3 && v.getT4() == 4 && v.getT5() == 5 && v.getT6() == 6 && v.getT7() == 7).isTrue()) .verifyComplete(); }
/** * Map the 7th part (T7) of this {@link Tuple7} into a different value and type, * keeping the other parts. * * @param mapper the mapping {@link Function} for the T7 part * @param <R> the new type for the T7 part * @return a new {@link Tuple7} with a different T7 value */ public <R> Tuple7<T1, T2, T3, T4, T5, T6, R> mapT7(Function<T7, R> mapper) { return new Tuple7<>(t1, t2, t3, t4, t5, t6, mapper.apply(t7)); }
@Override public boolean equals(@Nullable Object o) { if (this == o) return true; if (!(o instanceof Tuple8)) return false; if (!super.equals(o)) return false; @SuppressWarnings("rawtypes") Tuple8 tuple8 = (Tuple8) o; return t8.equals(tuple8.t8); }
@Test public void fn7() { Integer[] source = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8 }; Tuple7<Object, Object, Object, Object, Object, Object, Object> tuple = Tuples.fn7().apply(source); assertThat(tuple.getT1()).isEqualTo(1); assertThat(tuple.getT2()).isEqualTo(2); assertThat(tuple.getT3()).isEqualTo(3); assertThat(tuple.getT4()).isEqualTo(4); assertThat(tuple.getT5()).isEqualTo(5); assertThat(tuple.getT6()).isEqualTo(6); assertThat(tuple.getT7()).isEqualTo(7); assertThat(tuple) .isInstanceOf(Tuple8.class) .containsExactly(1, 2, 3, 4, 5, 6, 7, 8); }
/** * Map the 1st part (T1) of this {@link Tuple7} into a different value and type, * keeping the other parts. * * @param mapper the mapping {@link Function} for the T1 part * @param <R> the new type for the T1 part * @return a new {@link Tuple7} with a different T1 value */ public <R> Tuple7<R, T2, T3, T4, T5, T6, T7> mapT1(Function<T1, R> mapper) { return new Tuple7<>(mapper.apply(t1), t2, t3, t4, t5, t6, t7); }
@Test public void whenDelayMonoJust7() { MonoProcessor<Tuple7<Integer, Integer, Integer, Integer, Integer, Integer, Integer>> mp = MonoProcessor.create(); StepVerifier.create(Mono.zipDelayError(Mono.just(1), Mono.just(2), Mono.just(3), Mono.just(4), Mono.just(5), Mono.just(6), Mono.just(7))) .assertNext(v -> assertThat(v.getT1() == 1 && v.getT2() == 2 && v.getT3() == 3 && v.getT4() == 4 && v.getT5() == 5 && v.getT6() == 6 && v.getT7() == 7).isTrue()) .verifyComplete(); }