Introduction to Manual Testing - Software Testing

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.
It helps identify bugs, UI issues, and unexpected behavior.

• Testers use the application like real users to identify bugs and interface issues.
• Testers can explore the application freely to find unexpected problems.
• Test cases can be easily changed based on requirements and observations.
• Testing can start early in development to detect defects quickly.

Features

Manual testing includes several important characteristics that help ensure software quality, usability, and functionality before automation is implemented.

• Despite being time-consuming, it is essential for validating features, evaluating usability, and determining automation feasibility.
• Ideal for beginners and early testing stages.
• Verifies software functionality using predefined test cases without automation.
• Helps identify defects and ensures software meets user requirements.
• Provides a foundation for deciding automation feasibility.

Types of Manual Testing

1. Black Box Testing

Black Box Testing is a method where the tester checks the software without knowing its internal code or structure. Focus is only on inputs and expected outputs.

• No knowledge of coding required
• Based on requirements and functionality
• Tests user-facing features

Example: Entering login details and checking whether access is granted or denied.

2. White Box Testing

White Box Testing involves testing the internal structure, code, and logic of the application. The tester must have programming knowledge.

• Focus on logic, loops, conditions
• Performed by developers/testers

Example: Checking if all conditions in a login function (if/else) are working correctly.

3. Gray Box Testing

Gray Box Testing is a combination of Black Box and White Box Testing. The tester has partial knowledge of the internal system.

• Limited knowledge of code
• Focus on both functionality and structure
• Helps find hidden defects

Example: Testing a login system with some idea of database structure but not full code access.

Types Based on Testing Purpose

1. Functional Testing

Functional Testing tests what the system does — whether features work as per requirements.

2. Non-Functional Testing

Non-Functional Testing tests how well the system performs.

Steps in Manual Testing

The following diagram provides a detailed representation of the steps in the manual testing process.

Step 1: Understand Project Requirements

Manual testing begins with understanding what the software is expected to do.

• Functional Requirements: Verify features such as correct user login.
• Non-Functional Requirements: Validate performance, usability, and security (e.g., page load time under 2 seconds).
• User Stories & Design Documents: Understand user interactions and workflows.
• Stakeholder Input: Clarify requirements with clients, product managers, or designers.

Step 2: Creating a Test Plan

A test plan defines the testing strategy and objectives.

• Scope: Identifies features to be tested and exclusions.
• Objectives: Ensures core functionality and user experience.
• Resources: Specifies team members, tools, and timelines.
• Testing Techniques: Includes functional, usability, and exploratory testing.
• Environments: Defines staging or production-like setups.

Step 3: Design Test Cases

Test cases are clear, step-by-step scripts that ensure thorough manual testing. Test cases act as detailed guides for testers, ensuring every scenario is checked. Each test case includes:

• Test ID: A unique code, like TC_001, for easy tracking.
• Description: The goal, such as verifying with valid inputs.
• Preconditions: What’s needed before starting, like being on the search page.
• Steps: Actions to take, like pick tomorrow’s date, and click “Search.”
• Expected Result: The desired outcome, like a list of flights sorted by price.
• Postconditions: The system shows the results page.

Read More: How to Write Test Cases?

Step 4: Set Up the Test Environment

The test environment should closely resemble production.

• Install required applications.
• Configure project-specific settings.
• Ensure availability of test data.
• Verify hardware and software requirements.

Step 5: Execute Test Cases

Execute test cases step by step and interacting with the application as a user.

• Actual Results: What happens during execution.
• Pass/Fail Status: Whether the actual result matches the expected result.
• Observations: Any unexpected behavior or usability issues.

Step 6: Log and Report Defects

When a test fails or unexpected behavior occurs, log defects with:

• Defect ID: Unique identifier.
• Summary: Brief description of what the actual defect is
• Steps to Reproduce: Detailed steps to trigger the issue.
• Actual vs. Expected Results: What happened vs. what should have happened.
• Severity: Check whether the impact is critical, major, or minor.
• Attachments: Screenshots, logs, or videos for proof of the defect.

Step 7: Track and Verify Defects

After fixes are applied:

• Track defect status in the tool.
• Retest the fixed issues.
• Close or reopen defects based on results.

Step 8: Conduct Regression Testing

Regression testing ensures that defect fixes or new changes haven’t broken existing functionality.

• Affected areas are checked after resolving bugs.
• Check critical features.
• Check integration points to ensure they are working as before.

Step 9: Prepare Test Closure Reports

Once testing is complete, calculate the results against the test plan’s objectives and create a test closure report for the same:

• Summary: Overview of testing activities.
• Test Results: Number of test cases executed, passed, and failed.
• Defects Found: Total defects, their severity, and resolution status.
• Outstanding Issues: Any unresolved defects or risks.
• Lessons Learned: Insights for future testing.

Step 10: Provide Feedback and Recommendations

Analyze testing outcomes to provide actionable feedback to stakeholders, such as:

• Software quality.
• Process improvements.
• Future testing strategies.
• User experience insights.

Tools Used for Manual Testing

• TestRail: A user-friendly test management tool for organizing, executing, and reporting manual test cases with strong integrations and dashboards
• Xray (for Jira): A Jira-based test management tool that supports manual, automated, and BDD testing with full traceability and seamless integration
• Qase: A modern cloud-based test management platform with a simple UI, AI-powered test case creation, and built-in defect tracking
• Zephyr: A scalable test management solution supporting manual and exploratory testing with strong Jira integration and reporting features
• Tuskr: A lightweight and affordable cloud-based test management tool with an intuitive interface and collaboration features.

Need for Manual Testing

• Bug-free and Stability: The main goal of manual testing is to ensure that the application is bug-free, stable, in conformance with requirements, and delivers a stable product to the customers.
• Familiarity with the product: Manual testing helps the test engineers get more familiar with the product and get an end-user perspective. This helps them to write correct test cases for the software.
• Fixing the defects: Manual testing helps to ensure that the defects are fixed by the developer and that retesting has been done on the fixed defects.

Advantages of Manual Testing

• Fast and accurate visual feedback: It detects almost every bug in the software application and is used to test the dynamically changing GUI designs like layout, text, etc.
• Less expensive: It is less expensive as it does not require any high-level skill or a specific type of tool.
• No coding is required: No programming knowledge is required when using the black box testing method. It is easy to learn for the new testers.
• Efficient for unplanned changes: Manual testing is suitable in case of unplanned changes to the application, as it can be adopted easily.