One of the most common issues in manual software testing is with writing effective test cases (TCs). Even people with extensive experience in quality assurance services run into the same problems again and again. In this article, experts from the Exadel QA Practice will outline some tips for avoiding these issues and writing useful TCs.
How to Write Effective Test Cases
First of all, everyone has their own style and rules, so when you try to execute someone else’s TC, you may get confused. Additionally, it’s difficult to use TCs to cover all requirements without gaps. We have prepared a few manual testing tips and tricks to write effective test cases in software testing and avoid these issues:
Define the Area You Want to Cover with a TС
Before writing test cases in software testing, make a high-level checklist or use a set of the most important requirements to define your scope of work and main modules or elements which should be verified. Then divide them into logical parts to easily group cases in test scenarios.
- Add a label or component to your TC — it will help you to find cases from the necessary module
- Prioritize your TCs — this will help you find a set of the most critical cases
Keep Test Design Techniques in Mind
These test design techniques will help you save time, provide comprehensive test case coverage, and test your application deeply and rationally (based on ISTQB Glossary):
- Equivalence Partitioning. A black-box test design technique in which test cases are designed to execute representatives from equivalence partitions. In principle, test cases are designed to cover each partition at least once.
- Boundary Value Analysis. A black-box test design technique in which test cases are designed based on boundary values. BVA is based on testing at the boundaries between partitions. If you have ever done “range checking,” you were probably using the boundary value analysis technique, even if you didn’t realize it. Note that we cover both valid boundaries (in the valid partitions) and invalid boundaries (in the invalid partitions).
- Decision Table Testing. A black-box test design technique in which test cases are designed to exercise the combinations of conditions and the resulting actions shown in a decision table. A decision table is a good way to deal with combinations of things (e.g. inputs). This technique is also sometimes referred to as a “cause-effect table.” The reason for this is that there is an associated logic diagramming technique called “cause-effect graphing,” which is sometimes used to help derive the decision table.
- Use Case Testing. A black-box test design technique in which test cases are designed to exercise use case behaviors. It helps us identify test cases that exercise the whole system using business user scenarios and identify gaps in software applications that might not be found by testing individual components.
- State Transition Testing. A black-box test design technique in which test cases are designed to exercise elements of a state transition model. It’s better to use this technique when the system has a finite number of states. One of the advantages of the state transition technique is that the model can be as detailed or as abstract as you need it to be. When part of the system is more important (that is, requires more testing), a greater depth of detail can be modeled.
Analyze your software model and select one or more of these test design techniques to create your tests.
Use a Requirements Traceability Matrix in Testing for Visibility
To understand how to write effective test cases, it’s better to visualize the state of test coverage and see the relationship between requirements and test cases. Use a document (preferably a table) that maps and traces user requirements with test cases. This is known as a requirements traceability matrix for testing. It will demonstrate which requirements are not covered by test cases and show you areas with excess or insufficient testing.
Fill in your traceability matrix in testing not only with direct links to specification items and test cases, but also the most specific and critical bugs you find.
Make TCs Complex but Simple
A test case should contain all necessary details, relevant artifacts, and GUIs so you can avoid going through a pile of documents to complete a single test scenario. Test cases should be grouped into test suites in logical order. At the same time, a test case should be easy to understand and execute, and structured appropriately. All the steps for each TC should be atomic and in the correct sequence, plus include test data relevant for these input values.
It’s better to have a project TC template and build test cases in one style across the whole project.
Review Your Own and Your Teammates’ TCs
Once you have written the last TC of the test suite, go back to the beginning and review all TCs from the tester’s point of view. Make sure that all the steps you’ve mentioned are clear and that every step has an appropriate expected result.
Review TCs written by another tester. This will help you identify uncertainness, mistakes or gaps before testing.
Keep TCs Up to Date
Since requirements are constantly changing, you have to constantly update your test cases in your test executions. During execution, you may come up with new ideas, find new sub-conditions in a single TC, or even decide to add entirely new TCs. That’s why a periodic review and update of test scenarios will help to avoid the pesticide paradox and identify new bugs.
Link TCs to bugs and build new test cases if the issue you find is not already covered by a TC.
Add Examples and Test Data
Give a range of inputs as an example or attach prepared fields, documents as test data, especially where calculations are to be performed or the application’s behavior depends on inputs. By doing so, you’ll make sure that important test data isn’t ignored during the execution of TCs.
Distribute Test Cases Among Testers
Normally there are several testers who test different modules of a single application. TCs are divided among them according to the areas of application set to undergo testing. Some TCs related to the integration of an application may be executed by multiple testers, while others may be executed by only a single tester.
Remember to rotate test case execution for different areas between QAs for more effective testing and new perspectives.
Don’t Forget About Your Checklist
Remember that TCs are not the only test documentation used for manual testing. Analyze the size and business logic of the application, duration of the project, team size, and customer expectations. For short-term projects with clear and simple logic or when we lack QA resources, time or when the logic of application changes too often, it’s more time-efficient to use checklists instead of test cases. One of the good practices is to have a check-list for specific verification that we run not so often, but it is important to have it as a list of checks.
Use a checklist for smoke/sanity tests on big projects with complex logic even if detailed test cases exist. It helps to concentrate on the most important scenarios.
Manual testers should always be asking themselves how to write effective test cases better, as it has a major impact on the entire testing process. The process of writing test cases should be properly planned in advance and completed in a well-organized manner. If you’re responsible for this, keep in mind that in addition to making your life easier, proper documentation will help your whole team, including other testers, developers, BAs, and a customer. The test document should be understandable for all of its users, easily maintainable, and transparent. As a result, we will optimize the workload of the test team in test documentation support and provide solid and clear test documentation.
If it’s not possible for you to provide a high-quality testing process, approach an experienced company that offers a full range of manual and automated QA services. It’ll help you reduce the workload of all team members and provide effective tools to set and track your software objectives.
Author: Darya Adziarykha