How to write Test Cases in Software Testing? (with Format & Example)
By Shreya Bose, Community Contributor - September 4, 2023
What is a Test Case in Software Testing?
A test case refers to the actions required to verify a specific feature or functionality in software testing. The test case details the steps, data, prerequisites, and postconditions necessary to verify a feature.
It will lay out particular variables that QAs need to compare expected and actual results to conclude if the feature works. Test case components mention input, execution, and expected output/response. It tells engineers what to do, how to do it, and what results are acceptable.
Read More: How to create Test Scenarios with Examples
The Objective of Writing Test Cases in Software Testing
- To validate specific features and functions of the software.
- To guide testers through their day-to-day hands-on activity.
- To record a catalog of steps undertaken, which can be revisited in the event of a bug popping up.
- To provide a blueprint for future projects and testers so they don’t have to start work from scratch.
- To help detect usability issues and design gaps early on.
- To help new testers and devs quickly pick up testing, even if they join in the middle of an ongoing project.
Standard Test Case Format
- Test Case ID
- Test Scenario
- Test Steps
- Test Data
- Expected/Intended Results
- Actual Results
- Test Status – Pass/Fail
While writing test cases, remember to include:
- A reasonable description of the requirement
- A description of the test process
- Details related to testing setup: version of the software under test, data points, OS, hardware, security clearance, date, time, prerequisites, etc.
- Any related documents or attachments testers will require
- Alternative to prerequisites, if they exist
Test Case Prioritization is vital while writing test cases in software testing. Running all the test cases in a test suite requires much time and effort. As the number of features increases, testing the entire suite for every build is practically impossible. Test case prioritization helps overcome these challenges.
How to write Test Cases (Test Case Example)
Let’s build a test case example based on a specific scenario. Here is a sample case.
- Test Case ID: #BST001
- Test Scenario: To authenticate a successful user login on Gmail.com
- Test Steps:
- The user navigates to Gmail.com.
- The user enters a registered email address in the ’email’ field.
- The user clicks the ‘Next’ button.
- The user enters the registered password.
- The user clicks ‘Sign In.’
- Prerequisites: A registered Gmail ID with a unique username and password.
- Browser: Chrome v 86. Device: Samsung Galaxy Tab S7.
- Test Data: Legitimate username and password.
- Expected/Intended Results: Once username and password are entered, the web page redirects to the user’s inbox, displaying and highlighting new emails at the top.
- Actual Results: As Expected
- Test Status – Pass/Fail: Pass
Once test cases have been shaped, corresponding tests must be run on real browsers, devices, and operating systems. Remember that device fragmentation is a significant concern for every developer and tester. Every website has to work seamlessly on multiple device-browser-OS combinations. With 9000+ distinct devices being used to access the internet globally, all software must be optimized for different configurations, viewports, and screen resolutions.
Common Features of Test Cases
- Likely to be revised and updated regularly: Software requirements can change depending on business priorities or customer preferences. If requirements change, test cases will have to be altered accordingly. The detection of bugs and debugging steps may also require test cases to be changed.
- Likely to involve clustering: Test cases in a single test scenario usually have to be run in a specific sequence or in a group. In this case, particular prerequisites of one test case will apply to other cases in the same sequence.
- Likely to be interdependent: Often, test cases can depend on each other. This is especially true for layered applications with multi-tier business logic.
- Likely to be used by testers and developers: Test cases are helpful for developers and testers. For example, when devs fix bugs, test cases can be pretty valuable to replicate the said bug. In Test-Driven Development (TDD), devs create test cases to craft business logic, cover multiple test scenarios, and start writing code.
Best Practices for Writing Test Cases
- Prioritize clarity and transparency. Be clear, concise, and assertive in describing what the tester needs to do and what results they should ideally get.
- Focus on End-User requirements when writing sample test cases. Map test cases to reflect every aspect of the user journey. Use the Specifications Document and the Requirements Document to do so.
- Avoid repetition. If multiple tests can be executed with the same test case, use the Test Case ID to refer to the required test case.
- Keep Test Steps as minimal as possible. Ideally, keep it to 10-15 steps, if possible.
- Focus on achieving maximum test coverage. While 100% test coverage is rarely achievable, a high percentage can be attained with the right strategies.
- Create self-cleaning test cases. Test cases must revert the Test Environment to a pristine, pre-test state. Tests should not leave remnants of themselves in the environment when completed. This is an integral element of Configuration Management.
- Shape test cases for tests that return the same results no matter who runs them. Ensure that tests are self-standing.
Test Case Management with BrowserStack
Creating well-structured and result-oriented test cases is fundamental to running successful tests. Additionally, they ensure comprehensive test coverage and provide a clear plan for QAs to follow.
Using test management tools like BrowserStack, teams can:
- Ensure that all scenarios are covered to reduce the likelihood of defects in the final product
- Access robust reporting features that enable teams to track progress, identify issues, and analyze test results.
- Focus on critical areas that require more attention, improving overall efficiency.
- Navigate with fewer clicks and page loads, organize test cases using folders and tags.
- Easily search, sort, and filter test cases with pre-defined parameters.
- Leverage ready-to-use test case fields.
- Achieve better traceability by tracking test cases & test runs through two-way binding using the Jira app.
- Get a drilled-down overview of your test cases and test runs through the rich dashboard.
- Additionally, get rich insights into the performance and quality of your test runs through Test Observability.