Repository: jakartaee/data
Pull request #465 (2024-02-21 16:35:19)

Additional renames of Pageable to PageRequest
After pull #464 to rename Pageable was merged, I pulled down the latest and ran a search to find all additional occurrences. This pull cleans those up.


Patch:
diff --git a/README.adoc b/README.adoc
index f5ca6661..f2c87603 100644
--- a/README.adoc
+++ b/README.adoc
@@ -71,7 +71,7 @@ Jakarta Data also supports parameters to define pagination and sorting.
 @Repository
 public interface ProductRepository extends BasicRepository<Product, Long> {
 
- Page<Car> findByTypeOrderByName(CarType type, Pageable pageable);
+ Page<Car> findByTypeOrderByName(CarType type, PageRequest<?> pageRequest);
 
 }
 ----
diff --git a/api/src/main/java/jakarta/data/Order.java b/api/src/main/java/jakarta/data/Order.java
index 21995fe3..e8b8f264 100644
--- a/api/src/main/java/jakarta/data/Order.java
+++ b/api/src/main/java/jakarta/data/Order.java
@@ -39,7 +39,7 @@ import jakarta.data.repository.Query;
  * sort criteria during development. For example,</p>
  *
  * <pre>
- * {@code Page<Employee>} findByYearHired(int year, {@code Pageable<Employee>} pageRequest);
+ * {@code Page<Employee>} findByYearHired(int year, {@code PageRequest<Employee>} pageRequest);
  * ...
  * page1 = employees.findByYearHired(Year.now(),
  *                                   Order.by(_Employee.salary.desc(),
@@ -131,7 +131,7 @@ public class Order<T> implements Iterable<Sort<T>> {
 
     /**
      * Create a {@link PageRequest} for the specified page number
-     * of page size 10 (the default for {@code Pageable})
+     * of page size 10 (the default for {@code PageRequest})
      * of the query results sorted according to any static sort criteria that
      * is specified and the ordered list of {@link Sort} criteria
      * that is represented by this instance.
diff --git a/api/src/main/java/jakarta/data/metamodel/StaticMetamodel.java b/api/src/main/java/jakarta/data/metamodel/StaticMetamodel.java
index 3a615541..f07ed031 100644
--- a/api/src/main/java/jakarta/data/metamodel/StaticMetamodel.java
+++ b/api/src/main/java/jakarta/data/metamodel/StaticMetamodel.java
@@ -74,12 +74,12 @@ import jakarta.data.Sort;
  * <p>And use it to refer to entity attributes in a type-safe manner,</p>
  *
  * <pre>
- * {@code Pageable<Product>} pageRequest = Order.by(_Person.yearOfBirth.desc(),
- *                                          _Person.name_last.asc(),
- *                                          _Person.name_first.asc(),
- *                                          _Person.ssn.asc())
- *                                      .page(1)
- *                                      .size(20);
+ * {@code PageRequest<Product>} pageRequest = Order.by(_Person.yearOfBirth.desc(),
+ *                                             _Person.name_last.asc(),
+ *                                             _Person.name_first.asc(),
+ *                                             _Person.ssn.asc())
+ *                                         .page(1)
+ *                                         .size(20);
  * </pre>
  *
  * <p>When a class is annotated with {@code StaticMetamodel} and the
diff --git a/api/src/main/java/jakarta/data/metamodel/package-info.java b/api/src/main/java/jakarta/data/metamodel/package-info.java
index abca278b..04e56da3 100644
--- a/api/src/main/java/jakarta/data/metamodel/package-info.java
+++ b/api/src/main/java/jakarta/data/metamodel/package-info.java
@@ -47,11 +47,11 @@
  *
  * ...
  *
- * {@code Pageable<Product>} pageRequest = Order.by(_Product.price.desc(),
- *                                          _Product.name.asc(),
- *                                          _Product.id.asc())
- *                                      .page(1)
- *                                      .size(20);
+ * {@code Pagerequest<Product>} pageRequest = Order.by(_Product.price.desc(),
+ *                                             _Product.name.asc(),
+ *                                             _Product.id.asc())
+ *                                         .page(1)
+ *                                         .size(20);
  *
  * page1 = products.findByNameLike(namePattern, pageRequest);
  * </pre>
diff --git a/api/src/main/java/jakarta/data/page/KeysetAwareSlice.java b/api/src/main/java/jakarta/data/page/KeysetAwareSlice.java
index 5b46724e..073edd42 100644
--- a/api/src/main/java/jakarta/data/page/KeysetAwareSlice.java
+++ b/api/src/main/java/jakarta/data/page/KeysetAwareSlice.java
@@ -47,20 +47,20 @@ import jakarta.data.Sort;
  * &#64;OrderBy("lastName")
  * &#64;OrderBy("firstName")
  * &#64;OrderBy("id")
- * KeysetAwareSlice&lt;Employee&gt; findByHoursWorkedGreaterThan(int hours, {@code Pageable<Employee>} pageRequest);
+ * KeysetAwareSlice&lt;Employee&gt; findByHoursWorkedGreaterThan(int hours, {@code PageRequest<Employee>} pageRequest);
  * </pre>
  *
  * <p>You can use an offset-based {@link PageRequest} to request an initial page,</p>
  *
  * <pre>
- * page = employees.findByHoursWorkedGreaterThan(1500, Pageable.of(Employee.class).size(50));
+ * page = employees.findByHoursWorkedGreaterThan(1500, PageRequest.of(Employee.class).size(50));
  * </pre>
  *
  * <p>For subsequent pages, you can request pagination relative to the
  * end of the current page as follows,</p>
  *
  * <pre>
- * page = employees.findByHoursWorkedGreaterThan(1500, page.nextPageable());
+ * page = employees.findByHoursWorkedGreaterThan(1500, page.nextPageRequest());
  * </pre>
  *
  * <p>Because the page is keyset aware, the {@link PageRequest}
@@ -77,9 +77,9 @@ import jakarta.data.Sort;
  *
  * <pre>
  * Employee emp = ...
- * {@code Pageable<Employee>} pageRequest = Pageable.of(Employee.class)
- *                                          .size(50)
- *                                          .afterKeyset(emp.lastName, emp.firstName, emp.id);
+ * {@code PageRequest<Employee>} pageRequest = PageRequest.of(Employee.class)
+ *                                                .size(50)
+ *                                                .afterKeyset(emp.lastName, emp.firstName, emp.id);
  * page = employees.findByHoursWorkedGreaterThan(1500, pageRequest);
  * </pre>
  *
@@ -113,7 +113,7 @@ import jakarta.data.Sort;
  * &#64;OrderBy("birthYear")
  * &#64;OrderBy("id")
  * KeysetAwareSlice&lt;Customer&gt; getTopBuyers(int minOrders, float minSpent,
- *                                         {@code Pageable<Customer>} pageRequest);
+ *                                         {@code PageRequest<Customer>} pageRequest);
  * </pre>
  *
  * <p>Queries that are used with keyset pagination must return entities
@@ -176,7 +176,7 @@ public interface KeysetAwareSlice<T> extends Slice<T> {
      * previous page is requested) by assigning a page number of <code>1</code>
      * to such pages. This means that there can be multiple consecutive pages
      * numbered <code>1</code> and that
-     * <code>currentPage.previousPageable().next().page()</code>
+     * <code>currentPage.previousPageRequest().next().page()</code>
      * cannot be relied upon to return a page number that is equal to the
      * current page number.</p>
      *
diff --git a/api/src/main/java/jakarta/data/page/Page.java b/api/src/main/java/jakarta/data/page/Page.java
index f02719f4..24625b3d 100644
--- a/api/src/main/java/jakarta/data/page/Page.java
+++ b/api/src/main/java/jakarta/data/page/Page.java
@@ -25,7 +25,7 @@ package jakarta.data.page;
  * A page is obtained by supplying a {@link PageRequest} parameter to a repository method. For example,</p>
  *
  * <pre>
- * {@code Page<Employee>} findByYearHired(int year, {@code Pageable<?>} pageRequest);
+ * {@code Page<Employee>} findByYearHired(int year, {@code PageRequest<?>} pageRequest);
  * </pre>
  *
  * <p>Repository methods that are declared to return <code>Page</code> or
diff --git a/api/src/main/java/jakarta/data/page/Pagination.java b/api/src/main/java/jakarta/data/page/Pagination.java
index d5bd29f2..88150d23 100644
--- a/api/src/main/java/jakarta/data/page/Pagination.java
+++ b/api/src/main/java/jakarta/data/page/Pagination.java
@@ -27,7 +27,7 @@ import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
 
 /**
- * Built-in implementation of Pageable.
+ * Built-in implementation of PageRequest.
  */
 record Pagination<T>(long page, int size, List<Sort<T>> sorts, Mode mode, Cursor type) implements PageRequest<T> {
 
@@ -107,14 +107,14 @@ record Pagination<T>(long page, int size, List<Sort<T>> sorts, Mode mode, Cursor
             return new Pagination<T>((page + 1), this.size, this.sorts, Mode.OFFSET, null);
         } else {
             throw new UnsupportedOperationException("Not supported for keyset pagination. Instead use afterKeyset or afterKeysetCursor " +
-                    "to provide the next keyset values or obtain the nextPageable from a KeysetAwareSlice.");
+                    "to provide the next keyset values or obtain the nextPageRequest from a KeysetAwareSlice.");
         }
     }
 
     @Override
     public String toString() {
         StringBuilder s = new StringBuilder(mode == Mode.OFFSET ? 100 : 150)
-                .append("Pageable{page=").append(page)
+                .append("PageRequest{page=").append(page)
                 .append(", size=").append(size);
         if (type != null) {
             s.append(", mode=").append(mode)
diff --git a/api/src/main/java/jakarta/data/page/Slice.java b/api/src/main/java/jakarta/data/page/Slice.java
index d8e64db9..980bb5df 100644
--- a/api/src/main/java/jakarta/data/page/Slice.java
+++ b/api/src/main/java/jakarta/data/page/Slice.java
@@ -31,7 +31,7 @@ import java.util.List;
  * {@code Slice<Vehicle>} search({@code @By("make")} String make,
  *                       {@code @By("model")} String model,
  *                       {@code @By("year")} int designYear,
- *                       {@code Pageable<?>} pageRequest);
+ *                       {@code PageRequest<?>} pageRequest);
  * </pre>
  *
  * <p>Unlike {@link Page}, a {@code Slice} does not have awareness of the total number of pages
diff --git a/api/src/main/java/jakarta/data/page/package-info.java b/api/src/main/java/jakarta/data/page/package-info.java
index 6977de44..e3e3cdb5 100644
--- a/api/src/main/java/jakarta/data/page/package-info.java
+++ b/api/src/main/java/jakarta/data/page/package-info.java
@@ -30,9 +30,9 @@
  * to allow data to be read in slices or pages,</p>
  *
  * <pre>
- * Pageable.of(Person.class).size(25).sortBy(Sort.asc("lastName"),
- *                                           Sort.asc("firstName"),
- *                                           Sort.asc("id")); // unique identifier
+ * PageRequest.of(Person.class).size(25).sortBy(Sort.asc("lastName"),
+ *                                              Sort.asc("firstName"),
+ *                                              Sort.asc("id")); // unique identifier
  * </pre>
  *
  * <p>In the example above, even if multiple people have the same last names
diff --git a/api/src/main/java/jakarta/data/repository/BasicRepository.java b/api/src/main/java/jakarta/data/repository/BasicRepository.java
index cb55832d..bc786b85 100644
--- a/api/src/main/java/jakarta/data/repository/BasicRepository.java
+++ b/api/src/main/java/jakarta/data/repository/BasicRepository.java
@@ -167,7 +167,7 @@ public interface BasicRepository<T, K> extends DataRepository<T, K> {
      *
      * @param pageRequest the request for a paginated result; must not be {@code null}.
      * @return a page of entities; will never be {@code null}.
-     * @throws NullPointerException when {@code pageable} is {@code null}.
+     * @throws NullPointerException when {@code pageRequest} is {@code null}.
      * @throws UnsupportedOperationException for Key-Value and Wide-Column databases when the {@link PageRequest.Mode#CURSOR_NEXT}
      * or {@link PageRequest.Mode#CURSOR_PREVIOUS} pagination mode is selected.
      * @see PageRequest.Mode
diff --git a/api/src/main/java/jakarta/data/repository/OrderBy.java b/api/src/main/java/jakarta/data/repository/OrderBy.java
index 386150a7..901ee196 100644
--- a/api/src/main/java/jakarta/data/repository/OrderBy.java
+++ b/api/src/main/java/jakarta/data/repository/OrderBy.java
@@ -48,7 +48,7 @@ import java.lang.annotation.Target;
  * <pre>
  * &#64;OrderBy("lastName")
  * &#64;OrderBy("firstName")
- * Person[] findByZipCode(int zipCode, {@code Pageable<?>} pageRequest);
+ * Person[] findByZipCode(int zipCode, {@code PageRequest<?>} pageRequest);
  * </pre>
  *
  * <p>The precise meaning of ascending and descending order is
diff --git a/api/src/main/java/jakarta/data/repository/Param.java b/api/src/main/java/jakarta/data/repository/Param.java
index cdf85682..d4f5faef 100644
--- a/api/src/main/java/jakarta/data/repository/Param.java
+++ b/api/src/main/java/jakarta/data/repository/Param.java
@@ -34,7 +34,7 @@ import java.lang.annotation.Target;
  *
  *     {@code @Query("SELECT p from Products p WHERE (p.length * p.width * p.height <= :maxVolume)")}
  *     {@code Page<Product>} freeShippingEligible({@code @Param}("maxVolume") float volumeLimit,
- *                                        {@code Pageable<?>} pageRequest);
+ *                                        {@code PageRequest<?>} pageRequest);
  *
  *     ...
  * }
diff --git a/api/src/main/java/jakarta/data/repository/Query.java b/api/src/main/java/jakarta/data/repository/Query.java
index 0f1c5b37..9f98c386 100644
--- a/api/src/main/java/jakarta/data/repository/Query.java
+++ b/api/src/main/java/jakarta/data/repository/Query.java
@@ -65,7 +65,7 @@ import java.lang.annotation.Target;
  *     {@code @Query("SELECT DISTINCT p.name from Person p WHERE (LENGTH(p.name) >= :min AND LENGTH(p.name) <= :max)")}
  *     {@code Page<String>} namesOfLength({@code @Param}("min") int minLength,
  *                                {@code @Param}("max") int maxLength,
- *                                {@code Pageable<Person>} pageRequest);
+ *                                {@code PageRequest<Person>} pageRequest);
  *
  *     ...
  * }
@@ -80,7 +80,7 @@ import java.lang.annotation.Target;
  * to specify the entity class. For example,</p>
  *
  * <pre>
- * {@code Page<String>} page2 = people.namesOfLength(5, 10, page1.nextPageable(Person.class));
+ * {@code Page<String>} page2 = people.namesOfLength(5, 10, page1.nextPageRequest(Person.class));
  * </pre>
  */
 @Retention(RetentionPolicy.RUNTIME)
diff --git a/api/src/main/java/module-info.java b/api/src/main/java/module-info.java
index 00b371c9..3aab485f 100644
--- a/api/src/main/java/module-info.java
+++ b/api/src/main/java/module-info.java
@@ -486,8 +486,8 @@ import java.util.List;
  * For methods with the {@link Query} annotation or <i>Parameter-based Conditions</i>,
  * which have flexible naming, refer to the equivalent <i>Query by Method Name</i>
  * pattern in the table. For example, to identify the valid return types for a method,
- * {@code findNamed(String name, Pageable pagination)}, refer to the row for
- * {@code find...By...(..., Pageable)}.</p>
+ * {@code findNamed(String name, PageRequest pagination)}, refer to the row for
+ * {@code find...By...(..., PageRequest)}.</p>
  *
  * <table style="width: 100%">
  * <caption><b>Return Types when using Query by Method Name and Parameter-based Conditions</b></caption>
@@ -539,7 +539,7 @@ import java.util.List;
  * <td><code>Collection</code> subtypes</td>
  * <td>The subtype must have a public default constructor and support <code>addAll</code> or <code>add</code></td></tr>
  *
- * <tr style="vertical-align: top"><td><code>find...By...(..., Pageable)</code></td>
+ * <tr style="vertical-align: top"><td><code>find...By...(..., PageRequest)</code></td>
  * <td><code>Page&lt;E&gt;</code>, <code>KeysetAwarePage&lt;E&gt;</code>,
  * <br><code>Slice&lt;E&gt;</code>, <code>KeysetAwareSlice&lt;E&gt;</code></td>
  * <td>For use with pagination</td></tr>
@@ -626,26 +626,26 @@ import java.util.List;
  *
  * <pre>
  * Product[] findByNameLikeOrderByAmountSoldDescNameAsc(
- *           String pattern, {@code Pageable<Product>} pageRequest);
+ *           String pattern, {@code PageRequest<Product>} pageRequest);
  * ...
  * page1 = products.findByNameLikeOrderByAmountSoldDescNameAsc(
- *                  "%phone%", Pageable.of(Product.class).size(20));
+ *                  "%phone%", PageRequest.of(Product.class).size(20));
  * </pre>
  *
  * <h3>Sorting at Runtime</h3>
  *
  * <p>When requesting pages, you can dynamically supply sorting criteria
  * via the {@link PageRequest#sortBy(Sort)} method and other methods
- * of {@code Pageable} with the same name. For example,</p>
+ * of {@code PageRequest} with the same name. For example,</p>
  *
  * <pre>
- * Product[] findByNameLike(String pattern, {@code Pageable<Product>} pagination);
+ * Product[] findByNameLike(String pattern, {@code PageRequest<Product>} pagination);
  *
  * ...
- * {@code Pageable<Product>} page1Request = Pageable.of(Product.class)
- *                                          .size(25)
- *                                          .sortBy(Sort.desc("price"),
- *                                                  Sort.asc("name"));
+ * {@code PageRequest<Product>} page1Request = PageRequest.of(Product.class)
+ *                                                .size(25)
+ *                                                .sortBy(Sort.desc("price"),
+ *                                                        Sort.asc("name"));
  * page1 = products.findByNameLikeAndPriceBetween(
  *                 namePattern, minPrice, maxPrice, page1Request);
  * </pre>
@@ -654,9 +654,9 @@ import java.util.List;
  * page request from an {@link Order} instance, as follows,</p>
  *
  * <pre>
- * {@code Pageable<Product>} pageRequest = Order.by(_Product.price.desc(),
- *                                          _Product.name.asc())
- *                                      .pageSize(25));
+ * {@code PageRequest<Product>} pageRequest = Order.by(_Product.price.desc(),
+ *                                             _Product.name.asc())
+ *                                         .pageSize(25));
  * </pre>
  *
  * <p>To supply sort criteria dynamically without using pagination,
diff --git a/spec/src/main/asciidoc/portability.asciidoc b/spec/src/main/asciidoc/portability.asciidoc
index 7b14117a..2332b157 100644
--- a/spec/src/main/asciidoc/portability.asciidoc
+++ b/spec/src/main/asciidoc/portability.asciidoc
@@ -64,4 +64,4 @@ A Graph database, a specialized NoSQL variant, excels in managing intricate data
 
 Graph databases excel at answering queries that return rows containing flat objects, collections, or a combination of flat objects and connections. However, portability is only guaranteed when mapping rows to classes, and when queries specified via annotations or other supported means are used. It should be noted that queries derived from keywords and combinations of mapped classes/properties will be translated into vendor-specific queries.
 
-It is important to note that in Jakarta Data the Graph database supports the built-in repositories: `BasicRepository` and `PageableRepository`. Additionally, Query by Method Name is available, though developers should be aware that some keywords may not be universally supported. The full set of required keywords is documented in the section of the Jakarta Data module JavaDoc that is titled "Reserved Keywords for Query by Method Name".
+It is important to note that in Jakarta Data the Graph database supports the built-in repositories: `BasicRepository` and `DataRepository`. Additionally, Query by Method Name is available, though developers should be aware that some keywords may not be universally supported. The full set of required keywords is documented in the section of the Jakarta Data module JavaDoc that is titled "Reserved Keywords for Query by Method Name".
diff --git a/spec/src/main/asciidoc/repository.asciidoc b/spec/src/main/asciidoc/repository.asciidoc
index 9cc86097..5bf28d5e 100644
--- a/spec/src/main/asciidoc/repository.asciidoc
+++ b/spec/src/main/asciidoc/repository.asciidoc
@@ -81,12 +81,12 @@ The first type consists of built-in interfaces that are parent interfaces from w
                           +-----------------+
                           | BasicRepository |
                           +-----------------+
-                              ^         ^
-                              |         |
-                              |         |
-            +--------------------+    +--------------------+
-            | CrudRepository     |    | PageableRepository |
-            +--------------------+    +--------------------+
+                                  ^
+                                  |
+                                  |
+                        +--------------------+
+                        | CrudRepository     |
+                        +--------------------+
 
 ....
 
@@ -94,8 +94,6 @@ The `BasicRepository` interface includes some of the most common operations, whi
 
 The `CrudRepository` interface inherits from `BasicRepository`, adding `Insert` and `Update` operations that correspond to Create and Update in the CRUD (Create, Read, Update, Delete) pattern.
 
-The `PageableRepository` interface inherits from `BasicRepository`, adding built-in methods that leverage the pagination feature.
-
 The Java developer creates an interface that is annotated with the `@Repository` annotation and optionally extends one of the built-in repository interfaces.
 
 Given a `Product` entity where the ID is a `long` type, the repository can be:
@@ -737,7 +735,7 @@ Each parameter of an annotated query method must either:
 
 - have exactly the same name and type as a named parameter of the query,
 - have exactly the same type and position within the parameter list of the method as a positional parameter of the query, or
-- be of type `Limit`, `Order`, `Pageable`, or `Sort`.
+- be of type `Limit`, `Order`, `PageRequest`, or `Sort`.
 
 A repository with annotated query methods with named parameters must be compiled so that parameter names are preserved in the class file (for example, using `javac -parameters`), or the parameter names must be specified explicitly using the `@Param` annotation.
 
@@ -763,7 +761,7 @@ For example, using a named parameter:
 [source,java]
 ----
 @Query("where title like :title order by title")
-Page<Book> booksByTitle(String title, Pageable page);
+Page<Book> booksByTitle(String title, PageRequest<Book> pageRequest);
 ----
 
 [source,java]
@@ -796,7 +794,7 @@ The Jakarta Data implementation automatically recognizes the query annotations i
 A _parameter-based automatic_ query method is an abstract method annotated with the `Find` annotation. Jakarta Data infers a query based on the parameters of the method. The method return type identifies the entity. For example: `E`, `Optional<E>`, `Page<E>`, or `List<E>`, where `E` is an entity class. Each parameter must either:
 
 - have exactly the same type and name as a persistent field or property of the entity class, or
-- be of type `Limit`, `Order`, `Pageable`, or `Sort`.
+- be of type `Limit`, `Order`, `PageRequest`, or `Sort`.
 
 A repository with automatic query methods that are based on parameters must either be compiled so that parameter names are preserved in the class file (for example, using `javac -parameters`), or the corresponding entity attribute name for parameters must be specified explicitly using the `@By` annotation.
 
@@ -816,7 +814,7 @@ List<Book> booksByYear(Year year, Sort order, Limit limit);
 @Find
 Page<Book> find(@By("year") Year publishedIn,
                 @By("genre") Category type,
-                Pageable<?> pagination);
+                PageRequest<?> pagination);
 ----
 
 Automatic query methods annotated with `@Find` _are_ portable between providers.
@@ -1101,7 +1099,7 @@ Refer to the Jakarta Data module JavaDoc section on "Return Types for Repository
 
 Jakarta Data also supports particular parameters to define pagination and sorting.
 
-Jakarta Data recognizes, when specified on a repository method after the query parameters, the specific types, `Limit`, `Order`, `Pageable`, and `Sort`, to dynamically apply limits, pagination, and sorting to queries, respectively. The following example demonstrates these features:
+Jakarta Data recognizes, when specified on a repository method after the query parameters, the specific types, `Limit`, `Order`, `PageRequest`, and `Sort`, to dynamically apply limits, pagination, and sorting to queries, respectively. The following example demonstrates these features:
 
 [source,java]
 ----
@@ -1147,7 +1145,7 @@ Sort criteria is provided statically for a repository method by using the `Order
 
 ==== Dynamic Mechanisms for Sort Criteria
 
-Sort criteria is provided dynamically to repository methods either via `Sort` parameters or via a `Pageable` or `Order` parameter that has one or more `Sort` values. `Sort` and `Pageable` containing `Sort` must not both be provided to the same method. Similarly, `Order` and `Pageable` containing `Sort` must not both be provided to the same method.
+Sort criteria is provided dynamically to repository methods either via `Sort` parameters or via a `PageRequest` or `Order` parameter that has one or more `Sort` values. `Sort` and `PageRequest` containing `Sort` must not both be provided to the same method. Similarly, `Order` and `PageRequest` containing `Sort` must not both be provided to the same method.
 
 ==== Examples of Sort Criteria Precedence
 
@@ -1155,24 +1153,24 @@ The following examples work through scenarios where static and dynamic sort crit
 
 [source,java]
 ----
-// Sorts first by type. When type is the same, applies the Pageable's sort criteria
-Page<User> findByNameStartsWithOrderByType(String namePrefix, Pageable<?> pagination);
+// Sorts first by type. When type is the same, applies the PageRequest's sort criteria
+Page<User> findByNameStartsWithOrderByType(String namePrefix, PageRequest<?> pagination);
 
 // Sorts first by type. When type is the same, applies the criteria in the Sorts
 List<User> findByNameStartsWithOrderByType(String namePrefix, Sort<?>... sorts);
 
-// Sorts first by age. When age is the same, applies the Pageable's sort criteria
+// Sorts first by age. When age is the same, applies the PageRequest's sort criteria
 @OrderBy("age")
-Page<User> findByNameStartsWith(String namePrefix, Pageable<?> pagination);
+Page<User> findByNameStartsWith(String namePrefix, PageRequest<?> pagination);
 
 // Sorts first by age. When age is the same, applies the criteria in the Sorts
 @OrderBy("age")
 List<User> findByNameStartsWith(String namePrefix, Sort<?>... sorts);
 
-// Sorts first by name. When name is the same, applies the Pageable's sort criteria
+// Sorts first by name. When name is the same, applies the PageRequest's sort criteria
 @Query("SELECT u FROM User u WHERE (u.age > ?1)")
 @OrderBy("name")
-KeysetAwarePage<User> olderThan(int age, Pageable<?> pagination);
+KeysetAwarePage<User> olderThan(int age, PageRequest<?> pagination);
 ----
 
 === Pagination in Jakarta Data
@@ -1212,7 +1210,7 @@ Offset pagination offers several key features that make it a valuable approach f
 The following requirements must be met when using offset-based pagination:
 
 * The repository method signature must return `Slice` or `Page`. A repository method with return type of `Slice` or `Page` must raise `UnsupportedOperationException` if the database is incapable of offset pagination.
-* The repository method signature must accept a `Pageable` parameter.
+* The repository method signature must accept a `PageRequest` parameter.
 * Sort criteria must be provided and should be minimal.
 * The combination of provided sort criteria must define a deterministic ordering of entities.
 * The entities within each page must be ordered according to the provided sort criteria.
@@ -1232,7 +1230,7 @@ public class Person {
 }
 
 @Repository
-public interface People extends PageableRepository<Person, Long> {
+public interface People extends BasicRepository<Person, Long> {
 }
 ----
 
@@ -1265,10 +1263,10 @@ Code Execution:
 @Inject
 People people;
 
-Page<Person> page = people.findAll(Pageable.of(Person.class)
-                                           .page(1)
-                                           .size(2)
-                                           .sortBy(Sort.asc("id")));
+Page<Person> page = people.findAll(PageRequest.of(Person.class)
+                                              .page(1)
+                                              .size(2)
+                                              .sortBy(Sort.asc("id")));
 ----
 
 Resulting Page Content:
@@ -1286,8 +1284,8 @@ Next Page Execution:
 
 [source,java]
 ----
-Pageable<Person> nextPageable = page.nextPageable();
-Page<Person> page2 = people.findAll(nextPageable);
+PageRequest<Person> nextPageRequest = page.nextPageRequest();
+Page<Person> page2 = people.findAll(nextPageRequest);
 ----
 
 
@@ -1308,7 +1306,7 @@ Offset pagination is a valuable tool for Java developers when dealing with large
 
 ==== Keyset Pagination
 
-Keyset pagination aims to reduce missed and duplicate results across pages by querying relative to the observed values of entity properties that constitute the sorting criteria. Keyset pagination can also offer an improvement in performance because it avoids fetching and ordering results from prior pages by causing those results to be non-matching. A Jakarta Data provider appends additional conditions to the query and tracks keyset values automatically when `KeysetAwareSlice` or `KeysetAwarePage` are used as the repository method return type. The application invokes `nextPageable` or `previousPageable` on the keyset aware slice or page to obtain a `Pageable` which keeps track of the keyset values.
+Keyset pagination aims to reduce missed and duplicate results across pages by querying relative to the observed values of entity properties that constitute the sorting criteria. Keyset pagination can also offer an improvement in performance because it avoids fetching and ordering results from prior pages by causing those results to be non-matching. A Jakarta Data provider appends additional conditions to the query and tracks keyset values automatically when `KeysetAwareSlice` or `KeysetAwarePage` are used as the repository method return type. The application invokes `nextPageRequest` or `previousPageRequest` on the keyset aware slice or page to obtain a `PageRequest` which keeps track of the keyset values.
 
 For example,
 
@@ -1325,10 +1323,10 @@ You can obtain the initial page relative to an offset and subsequent pages relat
 
 [source,java]
 ----
-for (Pageable<?> p = Pageable.ofSize(50); p != null; ) {
+for (PageRequest<?> p = PageRequest.ofSize(50); p != null; ) {
   page = customers.findByZipcodeOrderByLastNameAscFirstNameAscIdAsc(55901, p);
   ...
-  p = page.nextPageable();
+  p = page.nextPageRequest();
 }
 ----
 
@@ -1337,14 +1335,14 @@ Or you can obtain the next (or previous) page relative to a known entity,
 [source,java]
 ----
 Customer c = ...
-Pageable<?> p = Pageable.ofSize(50).afterKeyset(c.lastName, c.firstName, c.id);
+PageRequest<?> p = PageRequest.ofSize(50).afterKeyset(c.lastName, c.firstName, c.id);
 page = customers.findByZipcodeOrderByLastNameAscFirstNameAscIdAsc(55902, p);
 ----
 
 The sort criteria for a repository method that performs keyset pagination must uniquely identify each entity and must be provided by:
 
 * `OrderBy` name pattern of the repository method (as in the examples above) or `@OrderBy` annotation(s) on the repository method.
-* `Sort` parameters of the `Pageable` that is supplied to the repository method.
+* `Sort` parameters of the `PageRequest` that is supplied to the repository method.
 
 ===== Example of Appending to Queries for Keyset Pagination
 
@@ -1356,7 +1354,7 @@ SELECT o FROM Customer o WHERE (o.zipCode = ?1)
                          ORDER BY o.lastName ASC, o.firstName ASC, o.id ASC
 ----
 
-When keyset pagination is used, the keyset values from the `Cursor` of the `Pageable` are available as query parameters, allowing the Jakarta Data provider to append additional query conditions. For example,
+When keyset pagination is used, the keyset values from the `Cursor` of the `PageRequest` are available as query parameters, allowing the Jakarta Data provider to append additional query conditions. For example,
 
 [source,jpql]
 ----
@@ -1377,14 +1375,14 @@ Other types of updates to data, however, will cause duplicate or missed results.
 ===== Restrictions on use of Keyset Pagination
 
 * The repository method signature must return `KeysetAwareSlice` or `KeysetAwarePage`. A repository method with return type of `KeysetAwareSlice` or `KeysetAwarePage` must raise `UnsupportedOperationException` if the database is incapable of keyset pagination.
-* The repository method signature must accept a `Pageable` parameter.
+* The repository method signature must accept a `PageRequest` parameter.
 * Sort criteria must be provided and should be minimal.
 * The combination of provided sort criteria must uniquely identify each entity such that the sort criteria defines a deterministic ordering of entities.
 * The entities within each page must be ordered according to the provided sort criteria.
 * Page numbers for keyset pagination are estimated relative to prior page requests or the observed absence of further results and are not accurate. Page numbers must not be relied upon when using keyset pagination.
 * Page totals and result totals are not accurate for keyset pagination and must not be relied upon.
-* A next or previous page can end up being empty. You cannot obtain a next or previous `Pageable` from an empty page because there are no keyset values relative to which to query.
-* A repository method that is annotated with `@Query` and performs keyset pagination must omit the `ORDER BY` clause from the provided query and instead must supply the sort criteria via `@OrderBy` annotations or `Sort` criteria of `Pageable`. The provided query must end with a `WHERE` clause to which additional conditions can be appended by the Jakarta Data provider. The Jakarta Data provider is not expected to parse query text that is provided by the application.
+* A next or previous page can end up being empty. You cannot obtain a next or previous `PageRequest` from an empty page because there are no keyset values relative to which to query.
+* A repository method that is annotated with `@Query` and performs keyset pagination must omit the `ORDER BY` clause from the provided query and instead must supply the sort criteria via `@OrderBy` annotations or `Sort` criteria of `PageRequest`. The provided query must end with a `WHERE` clause to which additional conditions can be appended by the Jakarta Data provider. The Jakarta Data provider is not expected to parse query text that is provided by the application.
 
 ===== Keyset Pagination Example with Sorts
 
@@ -1395,7 +1393,7 @@ Here is an example where an application uses `@Query` to provide a partial query
 @Repository
 public interface CustomerRepository extends BasicRepository<Customer, Long> {
   @Query("SELECT o FROM Customer o WHERE (o.totalSpent / o.totalPurchases > ?1)")
-  KeysetAwareSlice<Customer> withAveragePurchaseAbove(float minimum, Pageable<?> pagination);
+  KeysetAwareSlice<Customer> withAveragePurchaseAbove(float minimum, PageRequest<?> pagination);
 }
 ----
 
@@ -1403,13 +1401,13 @@ Example traversal of pages:
 
 [source,java]
 ----
-for (Pageable<?> p = Pageable.ofSize(25).sortBy(Sort.desc("yearBorn"),
-                                                Sort.asc("name"),
-                                                Sort.asc("id"));
+for (PageRequest<?> p = PageRequest.ofSize(25).sortBy(Sort.desc("yearBorn"),
+                                                      Sort.asc("name"),
+                                                      Sort.asc("id"));
      p != null; ) {
   page = customers.withAveragePurchaseAbove(50.0f, p);
   ...
-  p = page.nextPageable();
+  p = page.nextPageRequest();
 }
 ----
 
@@ -1421,7 +1419,7 @@ In this example, the application uses a cursor to request pages in forward and p
 ----
 @Repository
 public interface Products extends CrudRepository<Product, Long> {
-  KeysetAwareSlice<Product> findByNameContains(String namePattern, Pageable<?> pageRequest);
+  KeysetAwareSlice<Product> findByNameContains(String namePattern, PageRequest<?> pageRequest);
 }
 ----
 
@@ -1430,9 +1428,9 @@ Obtaining the next 10 products that cost $50.00 or more:
 [source,java]
 ----
 float priceMidpoint = 50.0f;
-Pageable<?> pageRequest = Pageable.ofSize(10)
-                                  .sortBy(Sort.asc("price"), Sort.asc("id"))
-                                  .afterKeyset(priceMidpoint, 0L);
+PageRequest<?> pageRequest = PageRequest.ofSize(10)
+                                        .sortBy(Sort.asc("price"), Sort.asc("id"))
+                                        .afterKeyset(priceMidpoint, 0L);
 KeysetAwareSlice<Product> moreExpensive = products.findByNameContains(pattern, pageRequest);
 ----
 
@@ -1472,7 +1470,7 @@ This keyset cursor-based pagination scenario uses the same `Person` entity and e
 @Repository
 public interface People extends BasicRepository<Person, Long> {
     @Find
-    KeysetAwarePage<Person> findAll(Pageable<Person> pagination);
+    KeysetAwarePage<Person> findAll(PageRequest<Person> pagination);
 }
 ----
 
@@ -1483,9 +1481,10 @@ Code Execution:
 @Inject
 People people;
 
-Pageable<Person> firstPageRequest = Pageable.of(Person.class)
-                                            .size(4)
-                                            .sortBy(Sort.asc("name"), Sort.asc("id"));
+PageRequest<Person> firstPageRequest = PageRequest.of(Person.class)
+                                                  .size(4)
+                                                  .sortBy(Sort.asc("name"),
+                                                          Sort.asc("id"));
 KeysetAwarePage<Person> page = people.findAll(firstPageRequest);
 ----
 
@@ -1514,7 +1513,7 @@ Next Page Execution:
 
 [source,java]
 ----
-Pageable<Person> nextPageRequest = page.nextPageable();
+PageRequest<Person> nextPageRequest = page.nextPageRequest();
 KeysetAwarePage<Person> page2 = people.findAll(nextPageRequest);
 ----
 


Test patch:
diff --git a/TESTING-GUIDELINE.adoc b/TESTING-GUIDELINE.adoc
index 3a604002..9c334418 100644
--- a/TESTING-GUIDELINE.adoc
+++ b/TESTING-GUIDELINE.adoc
@@ -41,7 +41,7 @@ structure:
 
 Example for happy paths (positive scenario):
 
-* `shouldCreatePageable`
+* `shouldCreatePageRequest`
 * shouldCreateLimitWithEqualsRange
 
 Example for negative scenario (or corner-case):
@@ -88,13 +88,13 @@ below example is `softly`:
 [source,java]
 ----
 assertSoftly(softly->{
-softly.assertThat(pageable.size()).isEqualTo(20);
-softly.assertThat(pageable.page()).isEqualTo(1L);
-softly.assertThat(pageable.mode()).isEqualTo(Pageable.Mode.CURSOR_NEXT);
-softly.assertThat(pageable.cursor().size()).isEqualTo(3);
-softly.assertThat(pageable.cursor().getKeysetElement(0)).isEqualTo("First");
-softly.assertThat(pageable.cursor().getKeysetElement(1)).isEqualTo(2L);
-softly.assertThat(pageable.cursor().getKeysetElement(2)).isEqualTo(3);
+softly.assertThat(pageRequest.size()).isEqualTo(20);
+softly.assertThat(pageRequest.page()).isEqualTo(1L);
+softly.assertThat(pageRequest.mode()).isEqualTo(PageRequest.Mode.CURSOR_NEXT);
+softly.assertThat(pageRequest.cursor().size()).isEqualTo(3);
+softly.assertThat(pageRequest.cursor().getKeysetElement(0)).isEqualTo("First");
+softly.assertThat(pageRequest.cursor().getKeysetElement(1)).isEqualTo(2L);
+softly.assertThat(pageRequest.cursor().getKeysetElement(2)).isEqualTo(3);
 });
 ----
 
diff --git a/api/src/test/java/jakarta/data/page/KeysetPageRequestTest.java b/api/src/test/java/jakarta/data/page/KeysetPageRequestTest.java
index fd7f339a..df4ccd8f 100644
--- a/api/src/test/java/jakarta/data/page/KeysetPageRequestTest.java
+++ b/api/src/test/java/jakarta/data/page/KeysetPageRequestTest.java
@@ -32,8 +32,8 @@ import static org.assertj.core.api.SoftAssertions.assertSoftly;
 class KeysetPageRequestTest {
 
     @Test
-    @DisplayName("Should include keyset values in next Pageable")
-    void shouldCreatePageableAfterKeyset() {
+    @DisplayName("Should include keyset values in next PageRequest")
+    void shouldCreatePageRequestAfterKeyset() {
         PageRequest<?> pageRequest = PageRequest.ofSize(20).afterKeyset("First", 2L, 3);
 
         assertSoftly(softly -> {
@@ -48,8 +48,8 @@ class KeysetPageRequestTest {
     }
 
     @Test
-    @DisplayName("Should include keyset values in next Pageable from Cursor")
-    void shouldCreatePageableAfterKeysetCursor() {
+    @DisplayName("Should include keyset values in next PageRequest from Cursor")
+    void shouldCreatePageRequestAfterKeysetCursor() {
         PageRequest.Cursor cursor = new KeysetCursor("me", 200);
         PageRequest<?> pageRequest = PageRequest.ofSize(35).sortBy(Sort.asc("name"), Sort.asc("id")).afterKeysetCursor(cursor);
 
@@ -65,8 +65,8 @@ class KeysetPageRequestTest {
     }
 
     @Test
-    @DisplayName("Should include keyset values in previous Pageable")
-    void shouldCreatePageableBeforeKeyset() {
+    @DisplayName("Should include keyset values in previous PageRequest")
+    void shouldCreatePageRequestBeforeKeyset() {
         PageRequest<?> pageRequest = PageRequest.ofSize(30).sortBy(Sort.desc("yearBorn"), Sort.asc("ssn")).beforeKeyset(1991, "123-45-6789").page(10);
 
         assertSoftly(softly -> {
@@ -81,8 +81,8 @@ class KeysetPageRequestTest {
     }
 
     @Test
-    @DisplayName("Should include keyset values in previous Pageable from Cursor")
-    void shouldCreatePageableBeforeKeysetCursor() {
+    @DisplayName("Should include keyset values in previous PageRequest from Cursor")
+    void shouldCreatePageRequestBeforeKeysetCursor() {
         PageRequest.Cursor cursor = new KeysetCursor(900L, 300, "testing", 120, 'T');
         PageRequest<?> pageRequest = PageRequest.ofPage(8).beforeKeysetCursor(cursor);
 
@@ -126,17 +126,17 @@ class KeysetPageRequestTest {
 
     @Test
     @DisplayName("Should be displayable as String with toString")
-    void shouldPageableDisplayAsString() {
+    void shouldPageRequestDisplayAsString() {
         PageRequest<?> pageRequest = PageRequest.ofSize(200).afterKeyset("value1", 1);
 
         assertSoftly(softly -> softly.assertThat(pageRequest.toString())
-              .isEqualTo("Pageable{page=1, size=200, mode=CURSOR_NEXT, 2 keys}"));
+              .isEqualTo("PageRequest{page=1, size=200, mode=CURSOR_NEXT, 2 keys}"));
 
         PageRequest<?> pageRequestWithSorts = PageRequest.ofSize(100).sortBy(Sort.desc("name"), Sort.asc("id"))
                                              .beforeKeyset("Item1", 3456);
 
         assertSoftly(softly -> softly.assertThat(pageRequestWithSorts.toString())
-              .isEqualTo("Pageable{page=1, size=100, mode=CURSOR_PREVIOUS, 2 keys, name DESC, id ASC}"));
+              .isEqualTo("PageRequest{page=1, size=100, mode=CURSOR_PREVIOUS, 2 keys, name DESC, id ASC}"));
     }
 
     @Test
@@ -186,8 +186,8 @@ class KeysetPageRequestTest {
             softly.assertThat(pageRequest25P1S0A1.equals(pageRequest25P1S1A1)).isFalse(); // with vs without sorting
             softly.assertThat(pageRequest25P1S2A1.equals(pageRequest25P1S1A1)).isFalse(); // different sorting
             softly.assertThat(pageRequest25P1S0A1.equals(pageRequest25P1S0A2)).isFalse(); // different keyset value
-            softly.assertThat(pageRequest25P1S0A1.equals(PageRequest.ofSize(25))).isFalse(); // Pageable with keyset vs Pageable
-            softly.assertThat(PageRequest.ofSize(25).equals(pageRequest25P1S0A1)).isFalse(); // Pageable vs Pageable with keyset
+            softly.assertThat(pageRequest25P1S0A1.equals(PageRequest.ofSize(25))).isFalse(); // PageRequest with keyset vs PageRequest
+            softly.assertThat(PageRequest.ofSize(25).equals(pageRequest25P1S0A1)).isFalse(); // PageRequest vs PageRequest with keyset
         });
     }
 
@@ -201,7 +201,7 @@ class KeysetPageRequestTest {
     }
 
     @Test
-    @DisplayName("Keyset should be replaced on new instance of Pageable")
+    @DisplayName("Keyset should be replaced on new instance of PageRequest")
     void shouldReplaceKeyset() {
         PageRequest<?> p1 = PageRequest.ofSize(30).sortBy(Sort.asc("lastName"), Sort.asc("firstName"), Sort.asc("id"))
                                          .afterKeyset("last1", "fname1", 100).page(12);
diff --git a/api/src/test/java/jakarta/data/page/PageRequestTest.java b/api/src/test/java/jakarta/data/page/PageRequestTest.java
index 591871c5..efdd18dd 100644
--- a/api/src/test/java/jakarta/data/page/PageRequestTest.java
+++ b/api/src/test/java/jakarta/data/page/PageRequestTest.java
@@ -32,7 +32,7 @@ class PageRequestTest {
 
     @Test
     @DisplayName("Should correctly paginate")
-    void shouldCreatePageable() {
+    void shouldCreatePageRequest() {
         PageRequest<?> pageRequest = PageRequest.ofPage(2).size(6);
 
         assertSoftly(softly -> {
@@ -42,8 +42,8 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Should create pageable with size")
-    void shouldCreatePageableWithSize() {
+    @DisplayName("Should create PageRequest with size")
+    void shouldCreatePageRequestWithSize() {
         PageRequest<?> pageRequest = PageRequest.ofSize(50);
 
         assertSoftly(softly -> {
@@ -67,7 +67,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Should create a new Pageable at the given page with a default size of 10")
+    @DisplayName("Should create a new PageRequest at the given page with a default size of 10")
     void shouldCreatePage() {
         PageRequest<?> pageRequest = PageRequest.ofPage(5);
 
@@ -79,13 +79,13 @@ class PageRequestTest {
 
     @Test
     @DisplayName("Should be displayable as String with toString")
-    void shouldPageableDisplayAsString() {
+    void shouldPageRequestDisplayAsString() {
         assertSoftly(softly -> softly.assertThat(PageRequest.ofSize(60).toString())
-              .isEqualTo("Pageable{page=1, size=60}"));
+              .isEqualTo("PageRequest{page=1, size=60}"));
 
         assertSoftly(softly -> softly.assertThat(PageRequest.ofSize(80).sortBy(Sort.desc("yearBorn"), Sort.asc("monthBorn"),
                         Sort.asc("id")).toString())
-              .isEqualTo("Pageable{page=1, size=80, yearBorn DESC, monthBorn ASC, id ASC}"));
+              .isEqualTo("PageRequest{page=1, size=80, yearBorn DESC, monthBorn ASC, id ASC}"));
     }
 
     @Test
@@ -113,7 +113,7 @@ class PageRequestTest {
     }
 
     @Test
-    void shouldCreatePageableSort() {
+    void shouldCreatePageRequestSort() {
         PageRequest<?> pageRequest = PageRequest.ofSize(3).sortBy(Sort.asc("name"));
 
         assertSoftly(softly -> {
@@ -155,7 +155,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Page number should be replaced on new instance of Pageable")
+    @DisplayName("Page number should be replaced on new instance of PageRequest")
     void shouldReplacePage() {
         PageRequest<?> p6 = PageRequest.ofSize(75).page(6).sortBy(Sort.desc("price"));
         PageRequest<?> p7 = p6.page(7);
@@ -171,7 +171,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Size should be replaced on new instance of Pageable")
+    @DisplayName("Size should be replaced on new instance of PageRequest")
     void shouldReplaceSize() {
         PageRequest<?> s90 = PageRequest.ofPage(4).size(90);
         PageRequest<?> s80 = s90.size(80);
@@ -185,7 +185,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Sorts should be replaced on new instance of Pageable")
+    @DisplayName("Sorts should be replaced on new instance of PageRequest")
     void shouldReplaceSorts() {
         PageRequest<?> p1 = PageRequest.ofSize(55).sortBy(Sort.desc("lastName"), Sort.asc("firstName"));
         PageRequest<?> p2 = p1.sortBy(Sort.asc("firstName"), Sort.asc("lastName"));
@@ -201,7 +201,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Sorts should be appended by the Pageable.asc method")
+    @DisplayName("Sorts should be appended by the Sort.asc method")
     void shouldAppendAscendingSort() {
         PageRequest<?> p1 = PageRequest.ofSize(50).asc("first");
         PageRequest<?> p2 = p1.asc("second");
@@ -219,7 +219,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Sorts should be appended by the Pageable.ascIgnoreCase method")
+    @DisplayName("Sorts should be appended by the Sort.ascIgnoreCase method")
     void shouldAppendCaseInsensitiveAscendingSort() {
         PageRequest<?> p1 = PageRequest.ofSize(40).ascIgnoreCase("first");
         PageRequest<?> p2 = p1.ascIgnoreCase("second");
@@ -237,7 +237,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Sorts should be appended by the Pageable.descIgnoreCase method")
+    @DisplayName("Sorts should be appended by the Sort.descIgnoreCase method")
     void shouldAppendCaseInsensitiveDescendingSort() {
         PageRequest<?> p1 = PageRequest.ofSize(30).descIgnoreCase("first");
         PageRequest<?> p2 = p1.descIgnoreCase("second");
@@ -255,7 +255,7 @@ class PageRequestTest {
     }
 
     @Test
-    @DisplayName("Sorts should be appended by the Pageable.desc method")
+    @DisplayName("Sorts should be appended by the Sort.desc method")
     void shouldAppendDescendingSort() {
         PageRequest<?> p1 = PageRequest.ofSize(20).desc("first");
         PageRequest<?> p2 = p1.desc("second");
diff --git a/api/src/test/java/jakarta/data/page/PaginationTest.java b/api/src/test/java/jakarta/data/page/PaginationTest.java
index 709f911e..c026f354 100644
--- a/api/src/test/java/jakarta/data/page/PaginationTest.java
+++ b/api/src/test/java/jakarta/data/page/PaginationTest.java
@@ -42,6 +42,6 @@ class PaginationTest {
             Pagination<?> pagination = new Pagination<>(1, 10, Collections.emptyList(), PageRequest.Mode.CURSOR_NEXT, new KeysetCursor("me", 200));
             pagination.next();
         }).isInstanceOf(UnsupportedOperationException.class)
-                .hasMessage("Not supported for keyset pagination. Instead use afterKeyset or afterKeysetCursor to provide the next keyset values or obtain the nextPageable from a KeysetAwareSlice.");
+                .hasMessage("Not supported for keyset pagination. Instead use afterKeyset or afterKeysetCursor to provide the next keyset values or obtain the nextPageRequest from a KeysetAwareSlice.");
     }
 }