Blog
142 Pagination Test Cases for QA Teams (With Examples)

Abhilash
Published on

Table of contents
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
Lorem ipsum
Pagination looks simple in a design review. Then it goes live and things start breaking. A search page that loads in 200ms falls over on page 47. A product grid that works fine in Chrome jumps around in Safari. A sort that worked yesterday forgets itself when someone goes to page two and back.
Pagination is everywhere, customers notice when it breaks, and most teams test far less of it than they should.
This list of pagination test cases is for QA engineers and SDETs who write and maintain tests for real applications. There are 142 of them. They start with the controls themselves, then move on to URLs, sorting, filters, edge cases, accessibility and the backend, which is where pagination usually breaks at scale.
You can use it to test a new pagination component, as a regression checklist for an existing one, or to show new testers what full coverage looks like.
How to Use These Pagination Test Cases
Each category starts with a quick note on what it covers, followed by a table of test cases with the expected result. The cases are general enough to work for most pagination, whether it’s an ecommerce listing, an admin table, search results, a dashboard or an enterprise grid. Just adjust the details, like page sizes, default sort and URL format, to match your application.
We’ve assumed a standard numbered control with First, Previous, page numbers, Next and Last. Infinite scroll, load more buttons and cursor-based pagination each have their own section.
Category | Test Cases |
|---|---|
Layout and display | 15 |
Page number navigation | 9 |
Previous and Next | 8 |
First and Last | 6 |
Page size selector | 8 |
Result counts | 8 |
URLs, deep links and SEO | 12 |
Browser back and forward | 6 |
Sorting | 8 |
Filters | 7 |
Search | 5 |
Boundary states | 4 |
Data across pages | 5 |
Infinite scroll | 8 |
Load more button | 5 |
Cursor-based pagination | 5 |
Backend and API | 10 |
Accessibility | 8 |
Browsers and screen sizes | 3 |
Localisation | 2 |
Category 1: Pagination Layout and Display Test Cases
Test Case | Expected Result |
|---|---|
Results are more than one page | The pagination control shows below the results |
All results fit on one page | The control is hidden, if the design says so |
Page number order | Numbers show in order: 1, 2, 3, up to the last page |
Current page | Clearly highlighted, for example bold or a different background |
Previous on page 1 | Disabled |
Next on the last page | Disabled |
First and Last buttons | Go to page 1 and the final page |
More pages than can be shown | Ellipses appear, for example 1, 2, 3 … 47, 48, 49 |
Page count | Matches the real number of pages |
Items-per-page selector | Shows the current selection |
Total count | Shows correctly, for example “Showing 1 to 10 of 247 items” |
Narrower screens | Less important controls hide neatly |
Spacing and alignment | Matches the design system |
Keyboard focus | The focus state is easy to see |
Hover | Hover states look the same on every clickable control |
Category 2: Page Number Navigation Test Cases
Clicking a page number is the most common pagination action, so it needs solid coverage.
Test Case | Expected Result |
|---|---|
Click page 2 | The right results load and the current page indicator updates |
Click a middle page, such as page 5 | The right results load |
Click the last page | The remaining items show, even if there are fewer than a full page |
Click the current page | Nothing reloads unnecessarily |
Move through pages | The visible page numbers shift, for example 1 to 5 on page 3, and 3 to 7 on page 5 |
Use the “Go to page” box | Entering a valid number goes to that page |
Enter a bad value in “Go to page” | Letters, zero or a number above the page count show a clear error |
Press Enter in “Go to page” | Goes to the page |
100 pages of results | The page numbers shorten sensibly, for example 1, 2, 3 … 50 … 98, 99, 100 |
Category 3: Previous and Next Test Cases
Most people click Next when they’re scrolling through results, so these buttons get a lot of use.
Test Case | Expected Result |
|---|---|
Next from page 1 | Goes to page 2 |
Next from a middle page | Goes forward one page |
Next on the last page | Disabled, and clicking does nothing |
Previous from page 2 | Goes back to page 1 |
Previous on page 1 | Disabled, and clicking does nothing |
Click Next several times quickly | Clicks are queued or ignored correctly, with no mixed-up results |
Keyboard shortcuts | Arrow keys or documented shortcuts work, where supported |
Slow load after Next | A loading indicator shows if loading takes longer than the agreed limit |
Category 4: First and Last Page Test Cases
First and Last matter most on big lists, where people want to jump straight to the start or end.
Test Case | Expected Result |
|---|---|
Click First | Goes to page 1 from any page |
First on page 1 | Disabled, and clicking does nothing |
Click Last | Goes to the final page |
Last on the last page | Disabled |
First from a deep page, such as page 47 | Goes to page 1 correctly |
Filters reduce the results | The last page number updates to match |
Category 5: Page Size Selector Test Cases
Changing how many items show per page is really common, and it’s one of the most bug-prone parts of pagination.
Test Case | Expected Result |
|---|---|
Default page size | Matches the agreed default, often 10, 20 or 25 |
Page size options | The options, such as 10, 25, 50 and 100, match the design |
Change from 10 to 25 | The first 25 items load on page 1 |
Change from 10 to 50 | The total page count updates correctly |
Change page size while on page 5 | The user lands where the spec says, usually page 1 or the page with the items they were viewing |
Navigate within the session | The chosen page size stays, if the spec says it should |
Come back in a new session | The page size is remembered for signed-in users, where supported |
Choose 100 per page with only 23 results | All 23 show on page 1, with no page 2 |
Category 6: Result Count Test Cases
“Showing 1 to 10 of 247” sounds easy, until you get to the edge cases.
Test Case | Expected Result |
|---|---|
Page 1, 10 per page | “Showing 1 to 10 of 247” |
Page 3 | “Showing 21 to 30 of 247” |
A partly full last page | “Showing 241 to 247 of 247” |
One result | “Showing 1 to 1 of 1” |
No results | “Showing 0 results”, or the agreed empty-state message |
Large counts | Thousands separators show, for example 1,234,567 |
Different locales | Number format follows the user’s locale, for example 1,234 or 1.234 |
Change a filter | The total updates straight away |
Category 7: URL, Deep Linking and SEO Test Cases
People should be able to bookmark and share a specific page. For public lists, search engines also need to reach every page. Keeping the page state in the URL makes both work.
Test Case | Expected Result |
|---|---|
Go to page 3 | The URL updates with the page, for example ?page=3 |
Open a URL with ?page=5 | Page 5 loads directly |
Change page size | The URL updates, for example ?pageSize=25, where supported |
Change the sort | The URL updates, where supported |
Apply filters | Filters show in the URL so the view can be bookmarked, where supported |
Refresh the page | The page, page size and filters stay the same |
?page=abc | Handled as the spec says, usually going to page 1 or showing a friendly error |
?page=999 on a five-page list | Handled as the spec says, usually going to the last page or showing a clear message |
?page=-1 | Handled as the spec says, usually going to page 1 |
?page=0 | Handled as the spec says, usually going to page 1 |
Crawlable links on public lists | Page links are real links with an href to a unique URL, not script-only buttons, so search engines can reach every page |
Canonical tags on public lists | Each page has its own canonical URL, rather than every page pointing to page 1, so later pages can still be indexed |
Category 8: Browser Back and Forward Test Cases
This is one of the most common places pagination breaks. People hit Back expecting to see the last page of results, and the app has forgotten where they were.
Test Case | Expected Result |
|---|---|
Back from page 2 | Returns to page 1, with everything as it was |
Forward after going back | Returns to page 2 |
Back after changing a filter | The filter change is undone cleanly |
Back from a detail page | Lands on the same results page, not page 1 |
Browser history | Each page change adds one history entry, not duplicates |
Scroll position after Back | The previous scroll position comes back, if the design says so |
Category 9: Sorting and Pagination Test Cases
Sorting changes the order of results, which changes what shows on each page, so it needs its own tests.
Test Case | Expected Result |
|---|---|
Sort on page 1 | Results reorder and stay on page 1 |
Sort on page 5 | The user lands where the spec says, usually back on page 1 |
Move between pages after sorting | The sort stays applied |
Click a sorted column again | The direction switches between ascending and descending |
Sort by more than one column | Secondary sorting works across pages, where supported |
Records with the same sort value | A fixed tiebreaker keeps their order the same, so items don’t move between pages on repeat visits |
Sort 100,000 records | The first page comes back within the agreed response time |
Sort indicator | The sorted column shows an arrow or highlight |
Category 10: Filters and Pagination Test Cases
Filters shrink the result list, and pagination has to keep up.
Test Case | Expected Result |
|---|---|
Apply a filter on page 1 | The new results start on page 1 |
Apply a filter on page 5 | The user lands where the spec says, usually back on page 1 |
Filter down to one page | Pagination behaves as the spec says, usually hiding |
Clear filters so results grow again | Pagination comes back |
Several filters together | All filters apply, and the total matches the combined result |
Clear all filters | The full list shows again, from page 1 |
Filters that match nothing | A clean empty state shows, with pagination hidden as the spec says |
Category 11: Search and Pagination Test Cases
Search works a lot like a filter, with a few extra rules.
Test Case | Expected Result |
|---|---|
New search from any page | Results start from page 1 |
Change the search term on a later page | Results go back to page 1 |
Empty search | Shows the default list, or a validation message, as the spec says |
Search with no results | A clean empty state shows, with pagination hidden as the spec says |
Search with one result | The single result shows without pagination, as the spec says |
Category 12: Boundary State Test Cases
Pagination has to work at the edges, not just in the middle. Zero results, one page and one result are already covered above, so these cases cover the rest.
Test Case | Expected Result |
|---|---|
Exactly two pages | The control shows First, Previous, 1, 2, Next and Last |
A partly full first page, for example with grouping | The count shows correctly |
A partly full last page | The right items show |
10,000+ items | Pagination stays within the agreed response time, and page numbers shorten sensibly |
Category 13: Data Across Pages Test Cases
The worst pagination bugs in production happen between pages. Records show up twice, go missing, or move around as the data changes. Most test lists skip these completely.
Test Case | Expected Result |
|---|---|
Check for duplicates between pages | An item on one page doesn’t appear again on the next, unless that’s expected |
Go through every page of a stable list | Every record shows exactly once, with nothing skipped |
Records added or removed while paging | No unexpected duplicates or gaps, matching how your pagination works (offset or cursor) |
The current last page disappears | The app moves the user to a valid page, instead of showing an error or empty page |
Retry a failed page load | The right page loads, without repeating results already on screen |
Category 14: Infinite Scroll Test Cases
Lots of apps use infinite scroll instead of page numbers. Here’s what to test.
Test Case | Expected Result |
|---|---|
Open the page | The first batch of items loads |
Scroll to the bottom | The next batch loads |
While the next batch loads | A spinner or placeholder shows |
Reach the end | A clear “No more results” message shows |
Scroll back up | Earlier items are still there, with no reloading |
Network fails while scrolling | An error and retry option show, and loaded items stay |
Back from a detail page | The scroll position and loaded items come back |
Very long scrolling sessions | Off-screen items are virtualised where needed, so the page stays fast |
Category 15: Load More Button Test Cases
A load more button is like infinite scroll, but the user clicks to get more.
Test Case | Expected Result |
|---|---|
More results available | The button shows below the list |
Click the button | The next batch is added to the list |
Everything has loaded | The button hides or is disabled |
While loading | The button shows a loading state |
End of results | The button is replaced with a “No more results” message |
Category 16: Cursor-Based Pagination Test Cases
Lots of modern APIs use cursors instead of page numbers, and the UI needs to handle them properly.
Test Case | Expected Result |
|---|---|
First load | No cursor is sent, and the first batch comes back with a cursor for the next page |
Next page | The returned cursor loads the next batch correctly |
End of results | A null cursor marks the end, and the UI handles it cleanly |
Change sort or filters | Any saved cursor is dropped and paging starts again from the beginning |
Out-of-date cursor | Nothing crashes, and paging usually restarts |
Category 17: Backend and API Test Cases
Pagination is as much an API job as a UI one, so test the backend too.
Test Case | Expected Result |
|---|---|
Offset and limit | Each request sends the right offset and limit for the page |
Cursor or page number | The API gets a valid cursor or page number |
Pagination details in the response | The total count or similar details are correct, where the API includes them, as many cursor-based APIs don’t |
Zero, negative or too-large page size | Rejected, capped or defaulted as the API contract says, never an inconsistent response |
Sorting | The server applies the sort, not just the browser |
Filtering | The server applies the filters |
No results | The API returns an empty list and the UI shows the empty state |
Server error (500) | A clear error shows, with a retry option |
Slow response | The loading state shows, then either loads or times out cleanly |
Lots of quick clicks | Responses arriving out of order don’t mix up what’s on screen |
Category 18: Pagination Accessibility Test Cases
Pagination is an interactive control, so everyone needs to be able to use it.
Test Case | Expected Result |
|---|---|
Keyboard only | Every control can be reached and used with a keyboard |
Tab order | Tabbing moves through the controls in a logical order |
Screen reader names | Every control has an accessible name, and the current page uses aria-current="page" |
Page changes | Screen reader users are told the page changed, through a live region or by moving focus |
Focus after a page change | Focus moves somewhere sensible, usually the top of the results |
Disabled Previous and Next | Screen readers announce them as disabled |
Colour contrast | Active, hover, focus and current-page states meet contrast rules (disabled controls are exempt under WCAG) |
Target size | Links and buttons are at least 24 by 24 CSS pixels, or meet the spacing exception, under WCAG 2.2 |
Category 19: Browser and Screen Size Test Cases
Test across the browsers and screen sizes your business has committed to support.
Test Case | Expected Result |
|---|---|
Supported browsers | Pagination works in every browser and version you support, usually Chrome, Edge, Firefox and Safari |
Responsive layout | Pagination fits cleanly at your breakpoints, on mobile, tablet and desktop sizes |
Touch | Controls are easy to tap on mobile and tablet browsers |
Category 20: Localisation Test Cases
If your app supports several languages, pagination has to follow along.
Test Case | Expected Result |
|---|---|
Translated labels | Previous, Next, First, Last and “Showing X to Y of Z” are translated correctly |
Right-to-left languages | Pagination is mirrored, with Previous and Next on the right sides |
Keeping a Pagination Test Suite Running
A full set of pagination test cases is really useful, but it takes work to keep running. It breaks for the same reasons most UI automation breaks. Library updates change the page structure, design refreshes change how page numbers look, new page size options appear, and sorting, filters and pagination get reworked every year or so. If your tests rely on fragile selectors, they’ll turn into a maintenance backlog within a couple of releases.
That changes when your tests can cope with the app changing, instead of breaking every time it does.
With Virtuoso QA, you write pagination tests in plain English, like “go to page 5 and check the right rows show”, instead of tying them to CSS classes. So a design refresh doesn’t break the whole suite.
Fixes you review: when the page structure changes, Virtuoso QA finds elements through other signals and suggests fixes for your team to accept or reject, so nothing changes without someone checking it.
Faster test writing: each step runs as you write it, and StepIQ suggests the next step, so building out these cases is quicker. Touchstone can also draft tests from your requirements and Jira stories, with a named person approving each one.
Existing tests brought across: GENerator converts existing Selenium pagination tests into plain English, so you don’t start from scratch.
UI and API in one test: UI checks and the API checks in Category 17 sit in the same test, so the backend, including the page-by-page checks in Category 13, is covered without a second tool.
Every browser you support: tests run in parallel across 2,000+ browser and OS combinations, which covers Category 19.
Pagination tests are a natural fit for regression, since they need to pass on every release. Virtuoso QA’s regression testing runs them automatically in your pipeline, with fixes your team reviews when the UI changes.
Also read: our guide to writing test cases covers formats, templates and examples you can use alongside this list.
Related Reads
Pagination Test Cases FAQs
What should pagination test cases cover?
What are the most common pagination bugs?
How do you test infinite scroll?
Should pagination be tested at the API level too?
How do you test pagination for accessibility?
Can pagination test cases be automated?
Written by

Abhilash
Industry Analyst, Test Automation
Abhilash tracks how AI is reshaping software testing, from pairwise coverage to regulatory accountability, and writes research-led pieces that cut through vendor noise with numbers.












