Manual tests – what you need to know
Conducting manual tests is searching for defects, verifying the correctness of functionality. The purpose of testing is also to check the operation of the application during various behaviors unusual for the user (end user), e.g. excessive clicks. Planning cases that may happen = preventing them. Less priority, but what is worth paying attention to, is usability, convenience and comfort of use. If something can be improved, it is worth signaling it to the developer.
Testing should not be ONLY about checking compliance with requirements and design specifications. Pay attention to validation, which should respond to the user’s needs.
Manual testing can be performed in different contexts
We conduct tests in the context of:
- Functional testing – WHAT DOES THE SYSTEM DO?
- Non-functional testing – HOW DOES THE SYSTEM WORK?
What are the differences between these approaches? We clarify:
- Functional tests are based on a functional specification, they verify a module or system for proper functionality
- Non-functional tests check, among others: usability, security, reliability, efficiency, compatibility
2. Sequence of actions:
- Functional tests are performed first
- Non-functional tests should be performed after functional tests
3. Use of specialized tools:
- Functional tests can be performed manually or automatically (using specialized software)
- To conduct non-functional tests, it is necessary to use dedicated tools and solutions
4. Output data:
- In the case of functional tests, these are business requirements
- In the context of non-functional tests, these may be, for example: performance parameters (scalability)
Manual test levels – another portion of practical knowledge
Modular testing – searching for as many defects/failures as possible at the early stage of the application life (the more errors detected earlier, the fewer defects/failures in later stages). Component tests can include functional and non-functional tests. Component testing = testing in isolation usually with code access.
Integration testing – interface testing between modules, interactions with other parts of the system (such as the operating system, file system and hardware), and interfaces between systems. Integration tests can include functional and non-functional tests.
System tests – should check functional and non-functional system requirements and data quality.
Acceptance testing – confirmation that the system works as expected/assumptioned.
Note: the table showing the relationships between individual types of tests shown in the graphic below is read from the left, starting from the rows.
Source: Profession: tester. From decision to gaining experience – Radosław Smilgin
Manual testing also includes:
- test planning
- monitoring test results
- reporting results
- modification of tests
- implementation of new tests
- preparation of documentation
3 tips proving that manual testing is still very important
Do you care about quality assurance? Manual tests will help to achieve this. In practice, a combination of manual and automated tests works best. However, let’s focus on manual verification of the correct functioning of the application:
- Tester as a real user – are automated test scripts able to verify visual or usability issues? Not completely. That is why looking at a given product from the perspective of a real user makes it easier to verify potential errors and discomfort when using the application.
- The manual tester can set his own path for exploring the application – remember that test automatic tests will perform only those activities that you indicate. Manual tests have much more freedom in the implementation of test scenarios. The tester can follow his own path, without any restrictions.
- Time and understanding of the concept – for some test scenarios, automation may prove too costly. It can take a long time to figure out how to test certain features, plan and write a script. During the same period, we can effectively test the same functionalities manually and even fix any errors. Automated tests really save time and allow you to achieve quick results, but in a broad context. Manual testing allows you to quickly provide feedback to the development team, especially during many changes to functional requirements.
The type of tests should be selected based on the scale of the project and its implementation time. First of all, you should remember about an individual approach to the tasks you perform. Each project is unique and has specific requirements. It is these factors that verify which type of tests will work best. Taking them into account, both the software developer and the investor can be sure that the product put into use has been checked in the most comprehensive way.
Want to know more about our approach to testing? Feel free to contact us