Anyone can automate end-to-end tests!
Our AI Test Agent enables anyone who can read and write English to become an automation engineer in less than an hour.
CONTENTS
What Are Edge Cases?Example of Edge Test CasesWhy Are Edge Test Cases Important?How to Write Effective Edge Test CasesPrioritizing Edge Test CasesAutomated Testing for Edge CasesReal World Scenario for Understanding Edge CasesHow to Identify Edge Test Case Defects?Common Examples of Edge Test CasesEdge Test Cases for a Login PageBest Practices for Edge Case TestingConclusion
Back to blogs
Edge Test CasesBoundary TestingTest Scenarios
What Is an Edge Case and How to Write Edge Test Cases
By PRAMIN PRADEEP
Updated on: 28/03/25
12 min read
CONTENTS
What Are Edge Cases?Example of Edge Test CasesWhy Are Edge Test Cases Important?How to Write Effective Edge Test CasesPrioritizing Edge Test CasesAutomated Testing for Edge CasesReal World Scenario for Understanding Edge CasesHow to Identify Edge Test Case Defects?Common Examples of Edge Test CasesEdge Test Cases for a Login PageBest Practices for Edge Case TestingConclusion
Focusing solely on standard use cases can leave your application vulnerable to unexpected failures. Edge test cases address this by testing software behavior under unusual or extreme conditions outside typical operating scenarios.
Edge cases are scenarios that push the system to its operational limits or beyond, testing how it behaves under rare or extreme conditions. These cases, while infrequent, play a vital role in uncovering hidden vulnerabilities and ensuring your application remains stable and secure in all situations.
This guide explores what edge cases are, why they’re essential, and how to effectively write, identify, and prioritize them to enhance software reliability and user experience.
What Are Edge Cases?
Edge cases are scenarios that test the system’s behavior at the boundaries or limits of its expected input or operational environment. They target extreme conditions that are unlikely but possible in real-world use cases. Identifying and testing these scenarios is crucial to ensure software stability and resilience under unexpected situations.
For example, if you’re developing a login page, you might face edge cases like an unusually long email address, a password with only special characters, or even an attempt to log in with an empty password field.
Example of Edge Test Cases
Edge test cases are designed to test the boundaries or extreme values of input data. These test cases help ensure that the system behaves as expected in unusual or extreme conditions. Here are some examples:
1.
Input Validation:
•
Maximum Length:
If an input field accepts a string, test with the maximum number of characters allowed (e.g., if the max length is 50, test with exactly 50 characters).
•
Minimum Length:
Test with the shortest input, such as an empty string or a string with only one character.
•
Null or Empty Input:
Provide an empty input (e.g., null, or an empty string "").
•
Invalid Characters:
Input special characters, like @, #, or non-ASCII characters if the input is expected to be alphanumeric.
2.
Boundary Values:
•
Numerical Ranges:
If the system expects a number in a certain range, test with values just below, within, and just above the range. For example, for a system that accepts numbers from 1 to 100:
•
Test with 0 (below the range).
•
Test with 1 (lower boundary).
•
Test with 100 (upper boundary).
•
Test with 101 (above the range).
3.
Dates and Time:
•
Leap Year:
Test with a date on a leap year, such as February 29th.
•
Month Boundary:
Test with the last day of the month and the first day of the next month (e.g., January 31st and February 1st).
•
Year Boundary:
Test with a boundary between years, like December 31st and January 1st.
•
Invalid Date:
Test with a non-existent date, such as February 30th.
4.
List/Array Boundaries:
•
Empty List:
If the system expects a list of items, test with an empty list.
•
One Item in List:
Test with a list containing a single item.
•
Maximum Number of Items:
Test with the maximum number of items allowed in the list or array.
•
Index Out of Bound:
Try accessing an element at an invalid index (e.g., an index that’s greater than the list size).
5.
File Upload/Download:
•
Maximum File Size:
Upload a file that is exactly at the maximum allowed size.
•
Empty File:
Upload an empty file or one with no content.
•
Invalid File Format:
Upload a file with an unsupported format.
6.
Performance and Load Testing:
•
Heavy Load:
Test with a large number of simultaneous users or a large volume of data to see if the system can handle it.
•
High Traffic:
Test with requests arriving at a very high frequency to evaluate the system’s scalability.
7.
Edge Cases for Form Submission:
•
Valid but Rare Input:
Test with values that are valid but infrequent, like a very long name, unusual punctuation, or a name with international characters.
•
Negative Numbers:
If the system expects only positive numbers, test with negative numbers to see if it handles them gracefully.
Why Are Edge Test Cases Important?
1.
Reveal Hidden Bugs
Edge test cases often uncover flaws that wouldn’t surface in normal use cases. For instance, a user uploading a file that exceeds the maximum size limit could crash the application if not handled properly.
2.
Improve User Experience
Unexpected crashes or errors disrupt the user journey. Testing edge cases helps in creating a smooth and frustration-free experience by preemptively addressing these issues.
3.
Ensure System Reliability
In sectors like healthcare or finance, a minor oversight can result in significant harm. Properly tested edge cases increase the reliability of your software in critical applications.
How to Write Effective Edge Test Cases
Writing effective edge test cases requires a keen understanding of the system's operational limits. Here are some steps to guide you through the process:
1.
Identify Limits:
Determine the boundaries and constraints of the system.
2.
Create Scenarios:
Design test scenarios that push the software beyond these boundaries.
3.
Document Expected Results:
Clearly define what the system should do in each case.
4.
Prioritize:
Focus on edge cases that impact user experience, legal compliance, or safety.
5.
Review and Optimize:
Continuously review your test cases based on feedback and results.
Prioritizing Edge Test Cases
Not all edge cases need to be tested or fixed. Here’s how you can prioritize effectively:
•
User Impact:
Evaluate the potential impact on the user experience.
•
Safety and Compliance:
Consider edge cases that could affect safety or regulatory compliance.
•
Frequency of Occurrence:
Identify the likelihood of each edge case happening.
•
Complexity of Fixes:
Determine the difficulty and resources required to address the edge cases.
Automated Testing for Edge Cases
Automation tools can help streamline the testing of edge cases. By scripting repeatable and controlled inputs, automation enables efficient testing of extreme scenarios that would otherwise be labor-intensive and prone to human error.
Popular Automation Tools
•
Selenium:
Ideal for web applications.
•
Appium:
Great for mobile applications.
•
Excellent for handling web, mobile, and API testing with codeless automation.
Real World Scenario for Understanding Edge Cases
For testing website BFSI (Banking, Financial Services, and Insurance) website (as example to understand edge cases better!), edge test cases are crucial for ensuring that the system functions correctly under extreme or unusual conditions. Here are some edge cases you might consider:
1.
Authentication and Authorization:
•
Invalid Login Credentials:
Test with incorrect username and password combinations, including:
•
Non-existent username.
•
Incorrect password for a valid username.
•
Case-sensitive username/password.
•
Account Lockout:
Test the behavior when a user exceeds the maximum number of login attempts.
•
Session Timeout:
Test how the system handles session expiry (e.g., automatically logging out after a period of inactivity).
•
Multiple Concurrent Logins:
Attempt to log in from different devices/browsers simultaneously and check the system's behavior.
2.
Form Inputs:
•
Account Number Field:
•
Test with the minimum and maximum valid length for an account number.
•
Test with special characters like #, $, or *.
•
Test with an invalid account number that’s too short or too long.
•
Transaction Amount:
•
Test with boundary values like 0, minimum, and maximum transaction amounts.
•
Test negative amounts or zero.
•
Test a large amount, such as the maximum allowed by the system, to check how it handles large transactions (e.g., large wire transfer).
•
Personal Identification Number (PIN):
•
Test with the correct and incorrect PIN lengths.
•
Test with valid but unexpected values, such as sequential digits (1234) or identical digits (1111).
3.
Payment and Transactions:
•
Invalid Credit/Debit Card Number:
•
Test with a valid card number but an expired date.
•
Test with a valid card number but incorrect CVV.
•
Test with an invalid card number (e.g., non-existent).
•
Currency Conversion:
•
Test with currency conversion at the minimum and maximum conversion limits.
•
Test with an unsupported or invalid currency.
•
Cross-Border Payment:
Test with payments made from a different country (testing for exchange rates, country-specific rules).
•
Multiple Payment Methods:
Test payments with different methods (credit card, bank transfer, wallet) simultaneously.
4.
Security and Data Integrity:
•
SQL Injection:
Test for SQL injection vulnerabilities by attempting to inject SQL queries into input fields like search or login.
•
Cross-Site Scripting (XSS):
Test with script injections in form fields, such as < script > alert('xss') < /script >.
•
Session Management:
Test if the session token persists across multiple pages or if logging out invalidates the session properly.
•
HTTPS/SSL:
Test if sensitive data, such as passwords, is transmitted securely over HTTPS (check for SSL certificate expiration).
•
Data Encryption:
Test if sensitive information (account balance, transaction history) is encrypted in storage and transmission.
5.
Data Entry and Validation:
•
Maximum Length Fields:
Test fields with the maximum allowable characters (e.g., names, email addresses, address fields).
•
Special Characters in Names:
Test for names with special characters such as hyphens (-), apostrophes ('), and spaces.
•
Address Field Edge Cases:
Test with unusually long addresses, address components with special characters, and empty address fields.
•
Invalid Date of Birth:
TTest with future dates or invalid dates like February 30th or 31st in months that don't have 31 days.
6.
Mobile Responsiveness:
•
Test Different Screen Sizes:
Test how the website adjusts to different screen sizes, including smartphones, tablets, and desktop browsers.
•
Touchscreen Navigation:
Test if the website’s touch controls (for mobile devices) are responsive and functional.
7.
Banking and Transactional Flow:
•
Multiple Transactions:
Test if the system can handle multiple simultaneous transactions (e.g., multiple people transferring funds or making payments at the same time).
•
Transaction History:
•
Test with large amounts of transaction history (e.g., displaying thousands of transactions).
•
Test with empty or no transaction history for a user.
•
Cheque Deposit:
Test if a user can deposit a cheque image with varying file formats, sizes, and resolution quality.
•
Loan Application:
Test loan applications with edge-case scenarios such as a very high loan amount, very low credit score, or invalid personal data.
8.
Account and Profile Management:
•
Updating Profile Information:
Test the updating of account details with boundary values for fields like name, address, and phone number.
•
Changing Password:
Test password change functionality by using:
•
Invalid old password.
•
New passwords that are too short, too long, or contain special characters.
•
A password that is the same as the previous one.
•
Account Deletion/Deactivation:
Test how the website handles deactivation or deletion requests, ensuring the account is fully removed and cannot be accessed again.
9.
Error Handling and Feedback:
•
Unexpected Inputs:
Test with invalid inputs or missing fields (e.g., leaving required fields blank).
•
404 Error Pages:
Test how the website handles broken links or missing pages (e.g., when users enter a non-existent URL).
•
Timeouts:
Test how the system behaves when operations take too long, e.g., when transferring large amounts or processing payments.
•
Invalid API Responses:
Test how the system handles API failures or slow responses, especially in financial transactions.
10.
Notifications and Alerts:
•
SMS/Email Alerts:
Test for edge cases in notification delivery, like invalid email addresses, full inboxes, or international numbers.
•
Push Notifications:
Test push notifications across various devices and browsers to ensure they function correctly.
11.
Cross-Browser Testing:
•
Browser Compatibility:
Test the website on different browsers (Chrome, Firefox, Edge, Safari, etc.) and ensure functionality is consistent.
•
Mobile Browser Testing:
Test on different mobile browsers (e.g., Chrome on Android, Safari on iOS) for consistent behavior.
How to Identify Edge Test Case Defects?
Identifying defects in edge test cases involves a systematic approach to testing scenarios at the boundaries of a system’s functionality. Here are key techniques to help you identify these defects effectively:
1.
Understand System Limits:
Begin by thoroughly reviewing requirements to define the system's operational boundaries, such as maximum field lengths, input constraints, and valid data types.
2.
Apply Boundary Value Analysis (BVA):
Test inputs at and just beyond the boundaries. For example, if a field accepts 1-100 characters, test with 0, 1, 100, and 101 characters to find defects.
3.
Use Equivalence Partitioning:
Divide input data into valid and invalid classes. Test one value from each class to cover various scenarios, including edge cases outside normal parameters.
4.
Perform Scenario-Based Testing:
Think from a user’s perspective and create edge case scenarios based on unusual sequences, like trying to log in with expired sessions or submitting unsupported characters.
5.
Stress and Load Testing:
Simulate high loads or extreme inputs to check system performance under stress, like multiple concurrent logins or oversized file uploads.
6.
Automate Edge Testing:
Automate repetitive edge test cases with tools like Selenium to ensure consistency and catch defects that manual testing might miss.
7.
Gather User Feedback:
Conduct beta testing and gather insights from real-world users to uncover overlooked edge scenarios.
By using these methods, you can effectively identify edge case defects, ensuring your system is resilient and performs reliably under all conditions.
Common Examples of Edge Test Cases
To give you a better idea, here are some examples of common edge test cases:
1.
Form Validation:
Testing fields with maximum and minimum allowed characters and special character combinations.
2.
File Upload:
Uploading files with various formats, sizes, and names.
3.
Concurrency Issues:
Simulating multiple users performing simultaneous operations on the system.
4.
Extreme Numerical Inputs:
Inputting values beyond the typical range, such as negative numbers or excessively large figures.
Edge Test Cases for a Login Page
Edge test cases focus on testing the login page's response to unusual or extreme scenarios to ensure robustness and security. Key examples include:
1.
Empty Fields:
Test login attempts with empty inputs to trigger error messages.
2.
Maximum Character Limit:
Validate the system’s handling of overly long usernames or passwords.
3.
SQL Injection:
Check for security vulnerabilities by testing common SQL injection inputs.
4.
Special Characters in Passwords:
Ensure passwords with only special characters are correctly handled.
5.
Extremely Long Email Addresses:
Validate against email addresses exceeding standard limits.
6.
Leading/Trailing Spaces:
Confirm input is trimmed to avoid incorrect login attempts.
7.
Expired Credentials:
Test logins with expired passwords and check for prompts to update.
8.
Multiple Incorrect Attempts:
Verify account lockout after consecutive failed attempts.
9.
Cross-Browser Testing:
Ensure consistent functionality across various browsers and devices.
10.
Session Timeout:
Check handling of idle login pages to enforce security.
These edge test cases help ensure a secure, user-friendly, and reliable login experience.
Best Practices for Edge Case Testing
•
Think like a user:
Consider how users might inadvertently interact with the software.
•
Anticipate unusual scenarios:
Plan for unanticipated conditions like server timeouts, network issues, or extreme hardware variations.
•
Embrace diverse perspectives:
Collaborate with developers, designers, and stakeholders to get a holistic view of possible edge cases.
Conclusion
Incorporating edge test cases into your testing strategy is more than just a proactive measure—it’s a necessity for delivering a high-quality software product. These tests prepare your application to handle rare, unexpected scenarios, ensuring it remains secure, resilient, and user-friendly. Paying attention to edge case testing could be the key to avoiding critical issues and maintaining user trust in your product.
FAQ's
Common edge cases include empty fields, maximum or minimum input values, special characters, and invalid file formats.
An edge use case tests software behavior at its limits or unusual conditions to assess reliability.
It's called an "edge case" because it tests scenarios at the boundaries or extremes of normal behavior.
"Edge" in testing ensures software can handle unexpected inputs and extreme situations reliably.
Written by
PRAMIN PRADEEP
With over 8 years of combined experience in various fields, Pramin have experience managing AI-based products and have 4+ years of experience in the SAAS industry. Pramin have played a key role in transitioning products to scalable solutions and adopting a product-led growth model. He have experience with B2B business models and bring knowledge in new product development, customer development, continuous discovery, market research, and both enterprise and self-serve models.
