From d5bbb4ee764963e768465963d8c0a9e496457b79 Mon Sep 17 00:00:00 2001 From: Bertrand Moreau Date: Mon, 25 Oct 2021 18:31:23 +0200 Subject: [PATCH 1/2] Add PageCollector Signed-off-by: Bertrand Moreau --- .../data/util/PageCollector.java | 278 ++++++++++++++++++ .../PageCollectorsToFilteredPageTest.java | 84 ++++++ ...ageCollectorsToFilteredSortedPageTest.java | 99 +++++++ .../data/util/PageCollectorsToPageTest.java | 72 +++++ .../util/PageCollectorsToSortedPageTest.java | 82 ++++++ 5 files changed, 615 insertions(+) create mode 100644 src/main/java/org/springframework/data/util/PageCollector.java create mode 100644 src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java create mode 100644 src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java create mode 100644 src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java create mode 100644 src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java diff --git a/src/main/java/org/springframework/data/util/PageCollector.java b/src/main/java/org/springframework/data/util/PageCollector.java new file mode 100644 index 0000000000..cdffc41785 --- /dev/null +++ b/src/main/java/org/springframework/data/util/PageCollector.java @@ -0,0 +1,278 @@ +package org.springframework.data.util; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.function.BiConsumer; +import java.util.function.BinaryOperator; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.function.Supplier; +import java.util.stream.Collector; +import java.util.stream.Collector.Characteristics; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.springframework.data.domain.Page; +import org.springframework.data.domain.PageImpl; +import org.springframework.data.domain.Pageable; + +public final class PageCollector { + + private static final Set characteristics = Collections.emptySet(); + + /** + * Reduce the {@link Stream} as {@link Page} based on the {@link Pageable} + * information. + * + * @param + * @param p + * @return a {@link Page} containing a subset of the {@link Stream} + */ + public static Collector, Page> toPage(final Pageable p) { + return new PageCollectorImpl<>(p); + } + + private static class PageCollectorImpl implements Collector, Page> { + + Pageable p; + + public PageCollectorImpl(final Pageable p) { + this.p = Objects.requireNonNull(p); + } + + @Override + public Set characteristics() { + return characteristics; + } + + @Override + public Supplier> supplier() { + return ArrayList::new; + } + + @Override + public BiConsumer, T> accumulator() { + return List::add; + } + + @Override + public BinaryOperator> combiner() { + return (left, right) -> { + left.addAll(right); + return left; + }; + } + + @Override + public Function, Page> finisher() { + return t -> { + final int pageNumber = p.getPageNumber(); + final int pageSize = p.getPageSize(); + final int fromIndex = Math.min(t.size(), pageNumber * pageSize); + final int toIndex = Math.min(t.size(), (pageNumber + 1) * pageSize); + + return new PageImpl<>(t.subList(fromIndex, toIndex), p, t.size()); + }; + } + + } + + /** + * Reduce the {@link Stream} as {@link Page} based on the {@link Pageable} + * information. + * + * @param + * @param p + * @return a {@link Page} containing a subset of the {@link Stream} sort + * following the {@link Comparator} + */ + public static Collector, Page> toSortedPage(final Pageable p, final Comparator c) { + return new SortedPageCollectorImpl<>(p, c); + } + + private static class SortedPageCollectorImpl implements Collector, Page> { + + Pageable p; + Comparator c; + + public SortedPageCollectorImpl(final Pageable p, final Comparator c) { + this.p = Objects.requireNonNull(p); + this.c = Objects.requireNonNull(c); + } + + @Override + public Set characteristics() { + return characteristics; + } + + @Override + public Supplier> supplier() { + return ArrayList::new; + } + + @Override + public BiConsumer, T> accumulator() { + return List::add; + } + + @Override + public BinaryOperator> combiner() { + return (left, right) -> { + left.addAll(right); + return left; + }; + } + + @Override + public Function, Page> finisher() { + return t -> { + final int pageNumber = p.getPageNumber(); + final int pageSize = p.getPageSize(); + final int fromIndex = Math.min(t.size(), pageNumber * pageSize); + final int toIndex = Math.min(t.size(), (pageNumber + 1) * pageSize); + + final List data = t.subList(fromIndex, toIndex); + data.sort(c); + + return new PageImpl<>(data, p, t.size()); + }; + } + + } + + /** + * Reduce the {@link Stream} as {@link Page} based on the {@link Pageable} + * information.
+ * + * The {@link Stream} is filtered before subset of data + * isolated + * + * @param + * @param p + * @return a {@link Page} containing a subset of the {@link Stream} + */ + public static Collector, Page> toFilteredPage(final Pageable p, final Predicate f) { + return new FilteredPageCollectorImpl<>(p, f); + } + + private static class FilteredPageCollectorImpl implements Collector, Page> { + + Pageable p; + Predicate f; + + public FilteredPageCollectorImpl(final Pageable p, final Predicate f) { + this.p = Objects.requireNonNull(p); + this.f = Objects.requireNonNull(f); + } + + @Override + public Set characteristics() { + return characteristics; + } + + @Override + public Supplier> supplier() { + return ArrayList::new; + } + + @Override + public BiConsumer, T> accumulator() { + return List::add; + } + + @Override + public BinaryOperator> combiner() { + return (left, right) -> { + left.addAll(right); + return left; + }; + } + + @Override + public Function, Page> finisher() { + return t -> { + final List data = t.stream().filter(f).collect(Collectors.toList()); + + final int pageNumber = p.getPageNumber(); + final int pageSize = p.getPageSize(); + final int fromIndex = Math.min(data.size(), pageNumber * pageSize); + final int toIndex = Math.min(data.size(), (pageNumber + 1) * pageSize); + + return new PageImpl<>(data.subList(fromIndex, toIndex), p, t.size()); + }; + } + + } + + /** + * Reduce the {@link Stream} as {@link Page} based on the {@link Pageable} + * information.
+ * + * The {@link Stream} is filtered then sorted then the subset of data + * isolated + * + * @param + * @param p + * @return a {@link Page} containing a subset of the {@link Stream} + */ + public static Collector, Page> toFilteredSortedPage(final Pageable p, final Predicate f, + final Comparator c) { + return new FilteredSortedPageCollectorImpl<>(p, f, c); + } + + private static class FilteredSortedPageCollectorImpl implements Collector, Page> { + + Pageable p; + Predicate f; + Comparator c; + + public FilteredSortedPageCollectorImpl(final Pageable p, final Predicate f, final Comparator c) { + this.p = Objects.requireNonNull(p); + this.f = Objects.requireNonNull(f); + this.c = Objects.requireNonNull(c); + } + + @Override + public Set characteristics() { + return characteristics; + } + + @Override + public Supplier> supplier() { + return ArrayList::new; + } + + @Override + public BiConsumer, T> accumulator() { + return List::add; + } + + @Override + public BinaryOperator> combiner() { + return (left, right) -> { + left.addAll(right); + return left; + }; + } + + @Override + public Function, Page> finisher() { + return t -> { + final List data = t.stream().filter(f).sorted(c).collect(Collectors.toList()); + + final int pageNumber = p.getPageNumber(); + final int pageSize = p.getPageSize(); + final int fromIndex = Math.min(data.size(), pageNumber * pageSize); + final int toIndex = Math.min(data.size(), (pageNumber + 1) * pageSize); + + return new PageImpl<>(data.subList(fromIndex, toIndex), p, t.size()); + }; + } + + } + +} diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java new file mode 100644 index 0000000000..82cab0e0ed --- /dev/null +++ b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java @@ -0,0 +1,84 @@ +package org.springframework.data.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; + +public class PageCollectorsToFilteredPageTest { + + private List ints; + private int size; + + @BeforeEach + void init() { + final Random rand = new Random(); + size = rand.nextInt(10000); + ints = IntStream.range(0, size).mapToObj(i -> rand.nextInt()).collect(Collectors.toList()); + } + + @Test + void fullPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = ints.stream().collect(PageCollector.toFilteredPage(pageable, i -> i > 0)); + + assertEquals(size, page.getSize()); + assertTrue(page.getContent().size() <= size); + for (final Integer element : page.getContent()) { + assertTrue(element > 0); + } + } + + @Test + void emptyPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = Collections.emptyList().stream() + .collect(PageCollector.toFilteredPage(pageable, i -> i > 0)); + + assertEquals(size, page.getSize()); + assertTrue(page.getContent().isEmpty()); + } + + @Test + void secondPage() { + final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); + final Page page = ints.stream().collect(PageCollector.toFilteredPage(pageable, i -> i < 0)); + + assertEquals(size / 4, page.getSize()); + assertTrue(page.getContent().size() <= size); + for (final Integer element : page.getContent()) { + assertTrue(element < 0); + } + } + + @Test + void checkData() { + final List datas = Arrays.asList("un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", + "dix"); + + final int size = datas.size(); + final Pageable pageable = Pageable.ofSize(size / 2).withPage(0); + final Page page = datas.stream().collect(PageCollector.toFilteredPage(pageable, t -> t.contains("i"))); + + assertEquals(size / 2, page.getSize()); + assertEquals(size / 2, page.getContent().size()); + for (final String string : page.getContent()) { + assertTrue(string.contains("i")); + assertFalse(!string.contains("i")); + } + assertIterableEquals(page.getContent(), Arrays.asList("trois", "cinq", "six", "huit", "dix")); + } + +} diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java new file mode 100644 index 0000000000..73fbc05cf9 --- /dev/null +++ b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java @@ -0,0 +1,99 @@ +package org.springframework.data.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; + +public class PageCollectorsToFilteredSortedPageTest { + + private List ints; + private int size; + + @BeforeEach + void init() { + final Random rand = new Random(); + size = rand.nextInt(10000); + ints = IntStream.range(0, size).mapToObj(i -> rand.nextInt()).collect(Collectors.toList()); + } + + @Test + void fullPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = ints.stream() + .collect(PageCollector.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); + + assertEquals(size, page.getSize()); + assertTrue(page.getContent().size() <= size); + + final List content = page.getContent(); + for (final Integer element : content) { + assertTrue(element > 0); + } + + for (int j = 1; j < content.size(); j++) { + assertTrue(Integer.compare(content.get(j - 1), content.get(j)) < 0); + } + } + + @Test + void emptyPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = Collections.emptyList().stream() + .collect(PageCollector.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); + + assertEquals(size, page.getSize()); + assertTrue(page.getContent().isEmpty()); + } + + @Test + void secondPage() { + final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); + final Page page = ints.stream() + .collect(PageCollector.toFilteredSortedPage(pageable, i -> i < 0, Integer::compare)); + + assertEquals(size / 4, page.getSize()); + assertTrue(page.getContent().size() <= size); + + final List content = page.getContent(); + for (final Integer element : content) { + assertTrue(element < 0); + } + + for (int j = 1; j < content.size(); j++) { + assertTrue(Integer.compare(content.get(j - 1), content.get(j)) < 0); + } + } + + @Test + void checkData() { + final List datas = Arrays.asList("un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", + "dix"); + + final int size = datas.size(); + final Pageable pageable = Pageable.ofSize(size / 2).withPage(0); + final Page page = datas.stream() + .collect(PageCollector.toFilteredSortedPage(pageable, t -> t.contains("i"), String::compareTo)); + + assertEquals(size / 2, page.getSize()); + assertEquals(size / 2, page.getContent().size()); + for (final String string : page.getContent()) { + assertTrue(string.contains("i")); + assertFalse(!string.contains("i")); + } + assertIterableEquals(page.getContent(), Arrays.asList("cinq", "dix", "huit", "six", "trois")); + } + +} diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java new file mode 100644 index 0000000000..d583499ee9 --- /dev/null +++ b/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java @@ -0,0 +1,72 @@ +package org.springframework.data.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; + +public class PageCollectorsToPageTest { + + private List ints; + private int size; + + @BeforeEach + void init() { + final Random rand = new Random(); + size = rand.nextInt(10000); + ints = IntStream.range(0, size).mapToObj(i -> rand.nextInt()).collect(Collectors.toList()); + } + + @Test + void fullPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = ints.stream().collect(PageCollector.toPage(pageable)); + + assertEquals(size, page.getSize()); + assertEquals(size, page.getContent().size()); + } + + @Test + void emptyPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = Collections.emptyList().stream().collect(PageCollector.toPage(pageable)); + + assertEquals(size, page.getSize()); + assertEquals(0, page.getContent().size()); + } + + @Test + void secondPage() { + final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); + final Page page = ints.stream().collect(PageCollector.toPage(pageable)); + + assertEquals(size / 4, page.getSize()); + assertEquals(size / 4, page.getContent().size()); + } + + @Test + void checkData() { + final List datas = Arrays.asList("un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", + "dix"); + + final int size = datas.size(); + final Pageable pageable = Pageable.ofSize(size / 5).withPage(2); + final Page page = datas.stream().collect(PageCollector.toPage(pageable)); + + assertEquals(size / 4, page.getSize()); + assertEquals(size / 4, page.getContent().size()); + assertEquals("cinq", page.getContent().get(0)); + assertEquals("six", page.getContent().get(1)); + + } + +} diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java new file mode 100644 index 0000000000..c062d1dc2d --- /dev/null +++ b/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java @@ -0,0 +1,82 @@ +package org.springframework.data.util; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertIterableEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.data.domain.Page; +import org.springframework.data.domain.Pageable; + +public class PageCollectorsToSortedPageTest { + + private List ints; + private int size; + + @BeforeEach + void init() { + final Random rand = new Random(); + size = rand.nextInt(10000); + ints = IntStream.range(0, size).mapToObj(i -> rand.nextInt()).collect(Collectors.toList()); + } + + @Test + void fullPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = ints.stream().collect(PageCollector.toSortedPage(pageable, Integer::compare)); + + assertEquals(size, page.getSize()); + assertEquals(size, page.getContent().size()); + + final List content = page.getContent(); + for (int i = 1; i < size; i++) { + assertTrue(Integer.compare(content.get(i - 1), content.get(i)) < 0); + } + } + + @Test + void emptyPage() { + final Pageable pageable = Pageable.ofSize(size); + final Page page = Collections.emptyList().stream() + .collect(PageCollector.toSortedPage(pageable, Integer::compare)); + + assertEquals(size, page.getSize()); + assertTrue(page.getContent().isEmpty()); + } + + @Test + void secondPage() { + final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); + final Page page = ints.stream().collect(PageCollector.toSortedPage(pageable, Integer::compare)); + + assertEquals(size / 4, page.getSize()); + assertEquals(size / 4, page.getContent().size()); + final List content = page.getContent(); + for (int i = 1; i < content.size(); i++) { + assertTrue(Integer.compare(content.get(i - 1), content.get(i)) < 0); + } + } + + @Test + void checkData() { + final List datas = Arrays.asList("un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", + "dix"); + + final int size = datas.size(); + final Pageable pageable = Pageable.ofSize(size / 2).withPage(1); + final Page page = datas.stream().collect(PageCollector.toSortedPage(pageable, String::compareTo)); + + assertEquals(size / 2, page.getSize()); + assertEquals(size / 2, page.getContent().size()); + assertIterableEquals(page.getContent(), Arrays.asList("dix", "huit", "neuf", "sept", "six")); + } + +} From 10220aeba90a2d2f8c62660ac6c1050e67bd66d6 Mon Sep 17 00:00:00 2001 From: Bertrand Moreau Date: Mon, 25 Oct 2021 18:39:28 +0200 Subject: [PATCH 2/2] Class rename Signed-off-by: Bertrand Moreau --- .../data/util/{PageCollector.java => PageCollectors.java} | 2 +- .../data/util/PageCollectorsToFilteredPageTest.java | 8 ++++---- .../data/util/PageCollectorsToFilteredSortedPageTest.java | 8 ++++---- .../data/util/PageCollectorsToPageTest.java | 8 ++++---- .../data/util/PageCollectorsToSortedPageTest.java | 8 ++++---- 5 files changed, 17 insertions(+), 17 deletions(-) rename src/main/java/org/springframework/data/util/{PageCollector.java => PageCollectors.java} (95%) diff --git a/src/main/java/org/springframework/data/util/PageCollector.java b/src/main/java/org/springframework/data/util/PageCollectors.java similarity index 95% rename from src/main/java/org/springframework/data/util/PageCollector.java rename to src/main/java/org/springframework/data/util/PageCollectors.java index cdffc41785..2f727c96bb 100644 --- a/src/main/java/org/springframework/data/util/PageCollector.java +++ b/src/main/java/org/springframework/data/util/PageCollectors.java @@ -20,7 +20,7 @@ import org.springframework.data.domain.PageImpl; import org.springframework.data.domain.Pageable; -public final class PageCollector { +public final class PageCollectors { private static final Set characteristics = Collections.emptySet(); diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java index 82cab0e0ed..e42725d18b 100644 --- a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java +++ b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredPageTest.java @@ -32,7 +32,7 @@ void init() { @Test void fullPage() { final Pageable pageable = Pageable.ofSize(size); - final Page page = ints.stream().collect(PageCollector.toFilteredPage(pageable, i -> i > 0)); + final Page page = ints.stream().collect(PageCollectors.toFilteredPage(pageable, i -> i > 0)); assertEquals(size, page.getSize()); assertTrue(page.getContent().size() <= size); @@ -45,7 +45,7 @@ void fullPage() { void emptyPage() { final Pageable pageable = Pageable.ofSize(size); final Page page = Collections.emptyList().stream() - .collect(PageCollector.toFilteredPage(pageable, i -> i > 0)); + .collect(PageCollectors.toFilteredPage(pageable, i -> i > 0)); assertEquals(size, page.getSize()); assertTrue(page.getContent().isEmpty()); @@ -54,7 +54,7 @@ void emptyPage() { @Test void secondPage() { final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); - final Page page = ints.stream().collect(PageCollector.toFilteredPage(pageable, i -> i < 0)); + final Page page = ints.stream().collect(PageCollectors.toFilteredPage(pageable, i -> i < 0)); assertEquals(size / 4, page.getSize()); assertTrue(page.getContent().size() <= size); @@ -70,7 +70,7 @@ void checkData() { final int size = datas.size(); final Pageable pageable = Pageable.ofSize(size / 2).withPage(0); - final Page page = datas.stream().collect(PageCollector.toFilteredPage(pageable, t -> t.contains("i"))); + final Page page = datas.stream().collect(PageCollectors.toFilteredPage(pageable, t -> t.contains("i"))); assertEquals(size / 2, page.getSize()); assertEquals(size / 2, page.getContent().size()); diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java index 73fbc05cf9..77f8312bcb 100644 --- a/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java +++ b/src/test/java/org/springframework/data/util/PageCollectorsToFilteredSortedPageTest.java @@ -33,7 +33,7 @@ void init() { void fullPage() { final Pageable pageable = Pageable.ofSize(size); final Page page = ints.stream() - .collect(PageCollector.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); + .collect(PageCollectors.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); assertEquals(size, page.getSize()); assertTrue(page.getContent().size() <= size); @@ -52,7 +52,7 @@ void fullPage() { void emptyPage() { final Pageable pageable = Pageable.ofSize(size); final Page page = Collections.emptyList().stream() - .collect(PageCollector.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); + .collect(PageCollectors.toFilteredSortedPage(pageable, i -> i > 0, Integer::compare)); assertEquals(size, page.getSize()); assertTrue(page.getContent().isEmpty()); @@ -62,7 +62,7 @@ void emptyPage() { void secondPage() { final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); final Page page = ints.stream() - .collect(PageCollector.toFilteredSortedPage(pageable, i -> i < 0, Integer::compare)); + .collect(PageCollectors.toFilteredSortedPage(pageable, i -> i < 0, Integer::compare)); assertEquals(size / 4, page.getSize()); assertTrue(page.getContent().size() <= size); @@ -85,7 +85,7 @@ void checkData() { final int size = datas.size(); final Pageable pageable = Pageable.ofSize(size / 2).withPage(0); final Page page = datas.stream() - .collect(PageCollector.toFilteredSortedPage(pageable, t -> t.contains("i"), String::compareTo)); + .collect(PageCollectors.toFilteredSortedPage(pageable, t -> t.contains("i"), String::compareTo)); assertEquals(size / 2, page.getSize()); assertEquals(size / 2, page.getContent().size()); diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java index d583499ee9..915a22fcfb 100644 --- a/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java +++ b/src/test/java/org/springframework/data/util/PageCollectorsToPageTest.java @@ -29,7 +29,7 @@ void init() { @Test void fullPage() { final Pageable pageable = Pageable.ofSize(size); - final Page page = ints.stream().collect(PageCollector.toPage(pageable)); + final Page page = ints.stream().collect(PageCollectors.toPage(pageable)); assertEquals(size, page.getSize()); assertEquals(size, page.getContent().size()); @@ -38,7 +38,7 @@ void fullPage() { @Test void emptyPage() { final Pageable pageable = Pageable.ofSize(size); - final Page page = Collections.emptyList().stream().collect(PageCollector.toPage(pageable)); + final Page page = Collections.emptyList().stream().collect(PageCollectors.toPage(pageable)); assertEquals(size, page.getSize()); assertEquals(0, page.getContent().size()); @@ -47,7 +47,7 @@ void emptyPage() { @Test void secondPage() { final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); - final Page page = ints.stream().collect(PageCollector.toPage(pageable)); + final Page page = ints.stream().collect(PageCollectors.toPage(pageable)); assertEquals(size / 4, page.getSize()); assertEquals(size / 4, page.getContent().size()); @@ -60,7 +60,7 @@ void checkData() { final int size = datas.size(); final Pageable pageable = Pageable.ofSize(size / 5).withPage(2); - final Page page = datas.stream().collect(PageCollector.toPage(pageable)); + final Page page = datas.stream().collect(PageCollectors.toPage(pageable)); assertEquals(size / 4, page.getSize()); assertEquals(size / 4, page.getContent().size()); diff --git a/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java b/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java index c062d1dc2d..4d14c02c2b 100644 --- a/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java +++ b/src/test/java/org/springframework/data/util/PageCollectorsToSortedPageTest.java @@ -31,7 +31,7 @@ void init() { @Test void fullPage() { final Pageable pageable = Pageable.ofSize(size); - final Page page = ints.stream().collect(PageCollector.toSortedPage(pageable, Integer::compare)); + final Page page = ints.stream().collect(PageCollectors.toSortedPage(pageable, Integer::compare)); assertEquals(size, page.getSize()); assertEquals(size, page.getContent().size()); @@ -46,7 +46,7 @@ void fullPage() { void emptyPage() { final Pageable pageable = Pageable.ofSize(size); final Page page = Collections.emptyList().stream() - .collect(PageCollector.toSortedPage(pageable, Integer::compare)); + .collect(PageCollectors.toSortedPage(pageable, Integer::compare)); assertEquals(size, page.getSize()); assertTrue(page.getContent().isEmpty()); @@ -55,7 +55,7 @@ void emptyPage() { @Test void secondPage() { final Pageable pageable = Pageable.ofSize(size / 4).withPage(2); - final Page page = ints.stream().collect(PageCollector.toSortedPage(pageable, Integer::compare)); + final Page page = ints.stream().collect(PageCollectors.toSortedPage(pageable, Integer::compare)); assertEquals(size / 4, page.getSize()); assertEquals(size / 4, page.getContent().size()); @@ -72,7 +72,7 @@ void checkData() { final int size = datas.size(); final Pageable pageable = Pageable.ofSize(size / 2).withPage(1); - final Page page = datas.stream().collect(PageCollector.toSortedPage(pageable, String::compareTo)); + final Page page = datas.stream().collect(PageCollectors.toSortedPage(pageable, String::compareTo)); assertEquals(size / 2, page.getSize()); assertEquals(size / 2, page.getContent().size());