Manual testing is a way of testing software applications, products, and systems while using a minimum number of tools or sometimes without using any tools. This blog will provide an overview of the fundamentals of writing effective test cases in manual testing and key tips and strategies to consider. Creating good test cases requires:
- careful planning,
- attention to detail, and
- a deep understanding of the software to be tested.
But don’t worry, with a well-designed test case; you can save time and effort and make the testing process super efficient.
Table Of Contents
What is a Test Case?
A Test Case is a specific set of conditions or variables under which a tester will determine whether an application, software system, or one of its features is working correctly or not. A Test Case aims to validate software features’ accuracy, completeness, and reliability. A test case usually includes the following details:
- test case ID,
- test case description,
- steps to follow,
- expected results,
- pass/fail criteria, and
- status of the test case.
A successful test case should identify correct and incorrect results, and any unexpected results should be reported as a bug. Test cases provide the basis for exhaustively testing a system and thus help increase the reliability and quality of the system by uncovering mistakes or gaps in the system.
What are the Manual Test Cases?
I can say,” Manual testing is a good old-fashioned human instinct and attention to detail.” Manual testing involves testing software manually, i.e., without using any automated tools. For executing this testing, you sometimes create test cases beforehand. These test cases are called manual test cases. A few examples of manual test cases include:
- validating that the login page is working properly,
- testing that the correct data is displayed on the search results page,
- ensuring the registration form is accurate before submission,
- testing the functioning of the shopping cart, and
- validating the order process.
Manual test cases are written in a clear and precise manner, which helps testers to understand and execute the tests accurately. Moreover, manual test cases can be used multiple times to execute tests, this helps to save time and money on software testing.
Read all about Manual Testing
How to write test cases: A step-by-step guide
If I explain to you in just a two-line summary of how to write a manual test case, it would be: 1. Identify the feature or functionality you wish to test. 2. Create a list of test cases that define specific actions to validate the functionality. Let’s see the detailed steps for writing test cases.
Step 1 – Test Case ID:
In this step, the tester will assign a unique identifier to the test case. This allows the tester to recall and identify the test case in the future easily.
Example: TC-01: Verify Login Functionality for a User
Step 2 – Test Case Description:
The tester will describe the test case, outlining what it is designed to do. The tester may also provide a brief overview of the expected behavior. An Example: Test Case Description: Test for Logging Into the application Given: A valid username and password for the web application When: User enters the username and password in the login page Then: the user should be able to log in to the application successfully. The Home page for the application should be displayed.
Step 3 – Pre-Conditions:
The tester will document any pre-conditions that need to be in place for the test case to run properly. It may include initial configuration settings or manually executing some previous tests. A Pre-Condition example in testing could be that the test environment must be set up, to be very similar to the production environment, including the same hardware, operating system, and software.
Step 4 – Test Steps:
The tester will document the detailed steps necessary to execute the test case. This includes deciding which actions should be taken to perform the test and also possible data inputs.
Example steps for our login test:
1. Launch the login application under test.
2. Enter a valid username and password in the appropriate fields.
3. Click the ‘Login’ button.
4. Verify that the user has been successfully logged in.
5. Log out and check if the user is logged out of the system.
Step 5 – Test Data:
The tester will define any necessary test data. For example, if the test case needs to test that login fails for incorrect credentials, then test data would be a set of incorrect usernames/passwords.
Step 6 – Expected Result:
The tester will provide the expected result of the test. This is the result the tester is looking to verify. Examples of how to define expected results:
1. A user should be able to enter a valid username and password and click the login button.
2. The application should authenticate the user’s credentials and grant access to the application.
3. The invalid user should not be able to enter the valid username and password; click the login button.
4. The application should reject the user’s credentials and display an appropriate error message.
Step 7 – Post Condition:
The tester will provide any cleanup that needs to be done after running the test case. This includes reverting settings or cleaning up files created during the test case. Example: 1. The user can successfully log in after providing valid credentials. 2. After providing invalid credentials, The user is shown the appropriate error message. 3. The user’s credentials are securely stored for future logins. 4. The user is taken to the correct page after successful login. 5. The user cannot access the page without logging in. 6. No unauthorized access to the user’s data.
Step 8 – Actual Result:
The tester will document the actual result of the test. This is the result the tester observed when running the test. Example: After entering the correct username and password, the user is successfully logged in and is presented with the welcome page.
Step 9 – Status:
The tester will report the status of the test. If the expected and actual results match, the test is said to have passed. If they do not match, the test is said to have failed.
Example: Tested the valid login functionality. Result: The user is able to log in with valid credentials. Overall Test Result: All the test steps were successfully executed, and the expected results were achieved. The login application is functioning as expected. Tested for Invalid Login functionality. Result: The user is unable to log in with invalid credentials. Overall Test Result: The invalid login functionality has been tested and verified to be working as expected
Best Practice for writing good Test Case.
When it comes to writing good test cases, certain best practices should be followed.
- First, it is important to identify the purpose of the test case and what exactly needs to be tested.
- Next, the test case should be written clearly and concisely, with step-by-step instructions for each action that needs to be taken. Also, it is important to consider all possible scenarios and edge cases to ensure thorough testing.
- Another important factor is maintaining organization and structure within your testing process by creating a logical flow of tests covering different aspects of the tested system.
- At last, it is always recommended to review and refine your test cases occasionally to maintain their quality over time.
By sticking to these best practices for writing good test cases, you can improve your success rate in identifying defects early in the software development lifecycle. This ensures optimal performance for end users.
Benefits of writing high-quality Test cases
Hey, did you know that making good test cases is important? It helps make sure that software stuff is top-notch. And good test cases help in lots of ways!
Let me narrow down to some essential facts here:
1. Accurately Identify Issues: High-quality test cases ensure the application is thoroughly tested and any issues or bugs are identified accurately.
2. Enhances test coverage: Test cases can assess different aspects of a software product or service, providing comprehensive coverage of the product to evaluate it. This means any bugs or other issues in the software can be identified and addressed before it is released for public use.
3. Enriches software quality: The amount of money and time needed for repairs and updates can be greatly reduced by recognizing faults and enhancing the general dependability and quality of the software before its launch.
4. Improves collaboration between stakeholders: High-quality test cases help stakeholders work collaboratively, as they can understand the objectives of the tests and share information and resources more effectively. This encourages a cohesive approach to testing and developing better products throughout the software development life cycle.
5. Improves user experience: High-quality test cases can enhance end users’ experience by assessing the software’s user experience and usability components. This helps to ensure that users are happy and satisfied with the software, which is essential for its success.
Manual Testing Test Case Examples
Here are some examples that you can easily understand about Manual Testing:
1. Login Page: We can assume a login application like Gmail.
- Test Case 1: Verify that the application allows users to input their username and password.
- Test Case 2: Verify that the application correctly validates the correct credentials.
- Test Case 3: Verify that the application displays an error message when the incorrect credentials are entered.
2. Search Functionality:
We can assume Google searches for this.
- Test Case 1: Verify that users can search for specific records in the database.
- Test Case 2: Verify that the application displays the query results correctly.
- Test Case 3: Verify that the application displays an error message when no matches are found.
3. File Uploads:
We can assume a resume upload in any job portal like LinkedIn or Monster
- Test Case 1: Verify that users are able to upload the correct type of file format.
- Test Case 2: Verify that the application does not allow users to upload malicious file formats.
- Test Case 3: Verify that the application displays an error message when the maximum file size is exceeded.
The types of manual testing test cases are functional test cases, regression test cases, integration test cases, system test cases, GUI test cases, security test cases, usability test cases, performance test cases, compatibility test cases, and acceptance test cases.
Test Case Execution and When to Automate
Talking about the test case execution part, the main objective is to verify whether the software behaves as intended, identify any defects or issues, and ensure that all requirements are met.
To answer the question, when to Automate?
The decision to use Automation Testing depends on the project and its specific requirements.
When you want to test something swiftly and without the need for a human tester to go through each step, automation testing is your best bet. Not only does it make the process quicker, but it also helps minimize errors. Automated tests can quickly cover larger areas of the application and surface any issues that need further investigation. Automated tests can also be used for repetitive processes such as checking user input fields for consistency, running queries, and verifying functionality over multiple scenarios. It can also help improve test coverage and maximize the return on investment.
Testsigma is a cloud-based AI-driven Test Automation Platform that brings automation capabilities to non-technical users. It is designed for Test Automation Engineers and Testers of any experience level and can automate end-to-end processes, including UI and API. You can write your test cases in NPL( Normal English) using this tool.
Testsigma can help automate the entire test lifecycle, including Test Case Execution, Test Results Analysis, Regression Tests Creation, and Reports Generation. It also helps automate cross-platform tests on multiple browsers, mobile phones, and operating systems. Testsigma also provides test report automation, enabling teams to use visualized reports and analytics to track progress, optimize test execution speed, and reduce rework.
Conclusion
So far, we have read in detail about manual testing. Writing effective and thorough test cases, and executing them helps ensure that a software product functions exactly as intended and that bugs are identified. Manual testing of test cases should include steps to replicate actions performed in the software and validate that results are accurate and consistent. A systematic approach to writing test cases with strong input and output validations will help uncover issues easily, giving the tester a thorough view of any software product.