Manual Testing is a software testing process where testers manually execute test cases without using automation tools. The tester checks the application's functionality, usability, and performance by acting like an end user.
- Helps identify bugs, UI issues, and unexpected behavior.
- Testers use the application like real users to validate functionality and user experience.
- Test cases can be easily modified based on changing requirements.
Features of Manual Testing
Manual testing includes several important characteristics that help ensure software quality, usability, and functionality before automation is implemented.
- Uses human observation to identify defects and unexpected behavior.
- Verifies software functionality using predefined test cases.
- Evaluates usability and overall user experience.
- Useful in the early stages of software testing.
- Supports exploratory testing and flexible test execution.
- Helps determine whether automation is required for future testing.
Testing Approaches in Manual Testing
Manual testing can be performed using different testing approaches based on the tester's knowledge of the application's internal structure. The three main approaches are White Box Testing, Black Box Testing, and Grey Box Testing.
- Black Box Testing: It is performed without access to the application's source code, focusing on inputs, outputs, and expected functionality.
- White Box Testing: It is performed with full knowledge of the application's source code, logic, and internal structure to verify code-level functionality.
- Gray Box Testing: It is performed with partial knowledge of the application's internal structure, combining both functional and structural testing approaches.
Types Based on Testing Purpose
Functional Testing
Functional Testing verifies what the system does by ensuring that features and functionalities work according to the specified requirements.
- Smoke Testing: Performs basic checks on critical functionalities to ensure the application is stable for further testing.
- Sanity Testing: Verifies specific functionalities after minor changes or bug fixes to ensure they work as expected.
- Integration Testing: Tests the interaction between different modules to ensure they work together correctly.
- System Testing: Tests the complete application as a whole to validate end-to-end functionality.
- Regression Testing: Re-tests existing functionalities after changes or bug fixes to ensure no new defects are introduced.
- User Acceptance Testing (UAT): Conducted by end users or clients to verify that the software meets business requirements.
Non-Functional Testing
Non-Functional Testing evaluates how well the system performs in terms of usability, performance, security, and compatibility.
- Usability Testing: Evaluates the application's ease of use, user interface, and overall user experience.
- Compatibility Testing: Verifies that the application works correctly across different browsers, devices, and operating systems.
- Performance Testing: Measures the application's speed, responsiveness, stability, and behavior under different workloads.
- Security Testing: Identifies vulnerabilities and ensures the protection of sensitive data and system resources.
Manual Testing Process
The following diagram provides a detailed representation of the steps in the manual testing process.
- Requirement Analysis: Understand and analyze the project requirements, user expectations, and business needs to identify what needs to be tested.
- Test Plan Creation: Create a test plan that defines the testing scope, objectives, resources, schedule, and testing approach.
- Test Case Creation: Design detailed test cases with test steps, expected results, and test data to validate application functionality.
- Test Environment Setup: Prepare the required hardware, software, tools, and test data to simulate the production environment.
- Test Case Execution: Execute the test cases and compare actual results with expected results to identify any issues.
- Defect Logging: Record defects with complete details such as description, severity, reproduction steps, and supporting evidence.
- Defect Fix & Reverification: Verify that reported defects have been fixed correctly and confirm that the issue no longer exists.
- Regression Testing: Retest affected and related functionalities to ensure that recent changes have not introduced new defects.
- Test Closure Report: Prepare a final report summarizing testing activities, results, defect status, and key lessons learned.
Tools Used for Manual Testing
- TestRail: A test management tool used to organize, execute, and track manual test cases with detailed reporting features.
- Xray (for Jira): A Jira-integrated testing tool that supports manual test management, traceability, and defect tracking.
- Qase: A cloud-based test management platform that simplifies test case creation, execution, and team collaboration.
- Zephyr: A test management solution that helps manage manual testing activities with strong Jira integration and reporting.
- Tuskr: A lightweight cloud-based test management tool for creating, managing, and tracking manual test cases efficiently.
Need for Manual Testing
Manual testing is important because it checks whether the application works correctly and helps identify quality and usability issues.
- Ensures the software works correctly and meets user requirements.
- Helps identify bugs, usability issues, and unexpected behavior.
- Allows testers to understand the application from an end-user perspective.
- Supports the creation of effective and realistic test cases.
- Verifies that reported defects are fixed properly through retesting.
- Improves the overall quality, stability, and reliability of the software.
Advantages of Manual Testing
- Detects usability issues and unexpected behavior through human observation.
- Does not require programming knowledge, so it is easier for many testers to perform.
- Supports exploratory testing by allowing testers to freely examine the application.
- Helps evaluate the applicationâs look, feel, and overall user experience.
- Cost-effective for small projects and applications with frequently changing requirements.
