Manual Testing

Manual Testing is a type of software testing in which test cases are executed manually by a
tester without the use of any automation tools. The purpose of manual testing is to identify
defects, ensure that the software behaves as expected, and verify that all functionalities
meet the requirements.

It is the most fundamental type of testing that simulates real-world usage by end-users and
helps ensure that the software is user-friendly and free of bugs.

Key Aspects of Manual Testing

1. Human-Centric Approach
Manual testing involves a tester performing actions on the software as a real user would.
This allows for a more intuitive and experience-based exploration of the system, which is
especially useful for:
- Finding usability issues
- Validating user experience (UX)
- Catching visual or layout issues

2. Test Case Design and Execution

In manual testing:
- Test cases are written based on software requirements and specifications.
- Testers execute these cases step-by-step, observing actual vs. expected outcomes.
- Results are documented, and if any discrepancies are found (bugs), they are reported to
the development team.

3. Types of Manual Testing

A. Based on Testing Types:
- Functional Testing – Checks whether the application functions as intended.
- Non-Functional Testing – Checks performance, usability, scalability, etc.

B. Based on Testing Levels:

- Unit Testing – Testing individual components (usually done by developers).
- Integration Testing – Testing the interaction between modules.
- System Testing – Testing the complete and integrated application.
- Acceptance Testing – Final testing from a business/user perspective before release.

C. Exploratory Testing:
Testers explore the application without predefined test cases. This is useful when
documentation is limited.
D. Ad-hoc Testing:
Informal testing without planning or documentation, often done to discover random issues.

Manual Testing Process (Life Cycle)

1. Requirement Analysis
Understand and analyze the software requirements.
Identify testable and non-testable requirements.

2. Test Planning
Define test strategy, scope, objectives, resources, tools, and schedule.
Risk identification and mitigation planning.

3. Test Case Design

Create detailed test cases and test scenarios.
Define input data, expected results, and execution conditions.

4. Test Environment Setup

Prepare the environment where testing will be executed.
Configure hardware, software, and network setup.

5. Test Execution
Execute the test cases manually.
Compare actual results with expected results.

6. Defect Logging and Reporting

Document defects with detailed information (steps to reproduce, severity, priority,
screenshots).
Communicate with developers for resolution.

7. Retesting and Regression Testing

Retest fixed defects.
Perform regression testing to ensure that changes haven’t affected existing functionality.

8. Test Closure
Finalize test activities.
Prepare test summary reports.
Evaluate testing objectives and lessons learned.

Advantages of Manual Testing

- Human Insight: Ideal for usability, UI, and user experience testing.
- Flexibility: Easier to adapt to changes in requirements.
- Cost-Effective: For short-term or small-scale projects, manual testing may be cheaper than
automation.
- Simplicity: Does not require knowledge of programming or automation tools.
Disadvantages of Manual Testing
- Time-Consuming: Repetitive tasks take longer than automated testing.
- Prone to Human Error: Fatigue or oversight may lead to missed defects.
- Limited Reusability: Test cases must be executed manually every time.
- Not Scalable: Inefficient for large projects with frequent test cycles.

Skills Required for Manual Testing

- Attention to Detail
- Analytical and Logical Thinking
- Communication Skills
- Understanding of SDLC and STLC
- Knowledge of Bug Tracking Tools (e.g., JIRA, Bugzilla)
- Basic Domain Knowledge (e.g., finance, healthcare, e-commerce)

Tools Used in Manual Testing

While manual testing does not involve automation tools, testers still use various support
tools, such as:
- Test Management Tools: TestRail, TestLink, Zephyr
- Bug Tracking Tools: JIRA, Bugzilla, Mantis
- Documentation Tools: Excel, Word, Confluence
- Collaboration Tools: Slack, Microsoft Teams, Trello

When to Use Manual Testing?

Manual testing is preferred in the following scenarios:
- Short-term projects
- User interface (UI) testing
- Usability testing
- Exploratory and ad-hoc testing
- Projects with frequently changing requirements
- Initial development stages where automation is not yet feasible.

Conclusion
Manual testing remains a cornerstone of software quality assurance. Despite the rise of
automation, manual testing plays a critical role in areas where human judgment, intuition,
and creativity are essential. It ensures a more human-centric and flexible approach to
testing, particularly in early development, usability validation, and exploratory scenarios.
Software Development Life Cycle (SDLC)
The Software Development Life Cycle (SDLC) is a systematic process used by software
developers and project managers to design, develop, test, and deploy high-quality software.
The goal of the SDLC is to produce software that meets or exceeds customer expectations,
reaches completion within timescales and cost estimates, and is efficient and error-free.

Key Objectives of SDLC

- Ensure software meets customer requirements.
- Deliver high-quality software products.
- Improve development speed and reduce project risks.
- Facilitate project planning and control.
- Enable effective communication among stakeholders.

Phases of SDLC

1. Requirement Gathering and Analysis

This is the first and crucial phase where business requirements are gathered from
stakeholders and users. Business analysts and project managers work together to
understand what the software must accomplish. The outcome is a clear and complete
Software Requirement Specification (SRS) document.

2. Feasibility Study
This phase determines whether the project is technically, financially, and operationally
feasible. The team evaluates the scope, cost, benefits, resources, and risks involved. If the
project is feasible, it moves forward.

3. System Design
Based on the requirements, system design is prepared. This includes architectural design,
interface design, database design, and data flow diagrams. The goal is to plan the system
architecture and define how the software will function.

4. Implementation (or Coding)

In this phase, actual development takes place. Developers write code based on the design
documents and predefined coding standards. This is typically the longest phase of the SDLC.

5. Testing
After development, the software is tested to identify bugs and verify that it meets the
requirements. Types of testing include unit testing, integration testing, system testing, and
user acceptance testing (UAT).
6. Deployment
Once the software passes testing, it is deployed to the production environment. This can be
a full deployment or staged, depending on project requirements.

7. Maintenance
After deployment, the software enters the maintenance phase. It involves fixing bugs that
were not discovered earlier, making updates, and enhancing features based on user
feedback. This phase ensures the software remains functional and relevant.

SDLC Models
There are various models used to implement the SDLC. The choice depends on the project
requirements, timeline, complexity, and client needs:
- Waterfall Model
- V-Model (Verification and Validation Model)
- Incremental Model
- Iterative Model
- Spiral Model
- Agile Model
- Big Bang Model

Benefits of SDLC
- Improved planning and control of software development processes.
- Better resource management and risk mitigation.
- High-quality software product delivery.
- Greater customer satisfaction.
- Timely project delivery within budget.

Conclusion
The Software Development Life Cycle (SDLC) provides a well-structured framework for
developing software efficiently and effectively. By following SDLC phases and choosing the
right development model, teams can minimize project risks, improve quality, and meet
client expectations.
Software Testing Life Cycle (STLC)
Software Testing Life Cycle (STLC) refers to a sequence of specific activities conducted
during the testing process to ensure software quality goals are met. The STLC is an integral
part of the Software Development Life Cycle (SDLC), but it focuses specifically on testing
and quality assurance.

Each phase in the STLC has specific goals and deliverables. The typical phases of the STLC
are as follows:

1. **Requirement Analysis**:
- In this phase, the testing team studies the requirements from a testing point of view to
identify testable requirements.
- Types of requirements include functional and non-functional.
- Activities:
- Identify types of tests to be performed.
- Identify test environment details.
- Review requirements for testability.
- Involve stakeholders for clarity on requirements.

2. **Test Planning**:
- This phase involves the preparation of the test plan and strategy documents.
- It defines the scope, approach, resources, and schedule of testing activities.
- Activities:
- Define objectives and scope.
- Estimate test efforts and resources.
- Identify tools required.
- Determine roles and responsibilities.
- Risk identification and mitigation planning.

3. **Test Case Development**:

- In this phase, test cases are created and test data is prepared.
- Activities:
- Design test cases and test scripts.
- Prepare test data.
- Review and baseline the test cases.

4. **Test Environment Setup**:

- This involves setting up software and hardware conditions under which a product is
tested.
- Activities:
- Identify the required environment setup.
 - Set up test servers, databases, and network.
- Configure hardware and software.
- Verify and validate the test environment.

5. **Test Execution**:
- During this phase, the test cases are executed in the specified environment.
- Activities:
- Execute test cases.
- Report bugs or defects.
- Retest and perform regression testing.

6. **Test Cycle Closure**:

- This phase involves calling out the testing team’s work completion.
- Activities:
- Evaluate cycle completion criteria based on test coverage and quality.
- Prepare test metrics.
- Document lessons learned.
- Conduct closure meetings.

**Importance of STLC**:
- Ensures systematic and organized testing.
- Helps in early detection of defects.
- Improves product quality.
- Enhances test coverage and traceability.

STLC is essential for ensuring the quality and reliability of software products by guiding the
testing process in a structured and methodical way.
How to Write Test Cases
1. Introduction
Test cases are an essential part of the software testing process. They define the conditions,
inputs, execution steps, and expected results for testing a specific function or feature of an
application. Writing effective test cases ensures the reliability and functionality of the
software being tested.

2. Test Case Structure

A well-written test case typically includes the following elements:

1. 1. Test Case ID
2. 2. Test Title
3. 3. Description
4. 4. Preconditions
5. 5. Test Steps
6. 6. Test Data
7. 7. Expected Result
8. 8. Actual Result
9. 9. Status (Pass/Fail)
10. 10. Comments

3. Writing a Test Case: Step by Step

Step 1: Identify Test Scenarios

Understand the requirements and identify various test scenarios that need to be validated.

Step 2: Define Test Case ID and Title

Assign a unique identifier to each test case and give it a descriptive title.

Step 3: Write Description and Preconditions

Provide a brief description of what the test case is validating. Mention any preconditions or
setup needed before executing the test.

Step 4: Detail the Test Steps

Clearly mention the steps to be followed during the test. Use numbered or bullet points for
clarity.

Step 5: Specify the Test Data

List the input data required for the test, including any variables or parameters.

Step 6: Define the Expected Result

Describe the expected output of the test if the application functions correctly.

Step 7: Record the Actual Result and Status

After execution, document the actual result and whether the test passed or failed.

4. Example Test Case

Field Description

Test Case ID TC_LOGIN_01

Test Title Valid Login

Description Verify login functionality with valid

credentials.

Preconditions User must be registered and application

must be running.

Test Steps 1. Launch the application

2. Enter valid username and password
3. Click on login button

Test Data Username: [email protected]

Password: Test@123

Expected Result User should be successfully logged in and

redirected to the dashboard.

Actual Result User successfully logged in (example

result)

Status Pass

Comments None
Test Cases for Gym Management
System Website
Test Case 1: User Registration
Test Case ID: TC_REG_01

Title: Valid User Registration

Description: Ensure that a user can successfully register with valid data.

Preconditions: User is on the registration page.

Test Steps:
1. Navigate to registration page
2. Enter valid name, email, password, confirm password
3. Click on 'Register'

Test Data:
Name: John Doe
Email: [email protected]
Password: Pass@123
Confirm Password: Pass@123

Expected Result: User is registered and redirected to the login page.

Actual Result:

Status:

Comments:

Test Case 2: User Login

Test Case ID: TC_LOGIN_01

Title: Valid Login

Description: Ensure login works with correct credentials.

Preconditions: User is registered.

Test Steps:
1. Navigate to login page
2. Enter valid email and password
3. Click on 'Login'

Test Data:
Email: [email protected]
Password: Pass@123

Expected Result: User is logged in and redirected to dashboard.

Actual Result:

Status:

Comments:

Test Case 3: Membership Plan Purchase

Test Case ID: TC_MEMBERSHIP_01

Title: Purchase Membership Plan

Description: Ensure that a user can purchase a membership plan successfully.

Preconditions: User is logged in.

Test Steps:
1. Go to membership section
2. Select a plan
3. Proceed to payment
4. Enter valid payment details
5. Confirm payment

Test Data:
Plan: Gold
Payment: Credit Card

Expected Result: Payment is successful and plan is activated.

Actual Result:

Status:

Comments:

Test Case 4: Booking a Training Session

Test Case ID: TC_BOOKING_01
Title: Book Training Session

Description: Ensure that a logged-in user can book a training session.

Preconditions: User is logged in and has an active membership.

Test Steps:
1. Navigate to 'Book a Session'
2. Choose date and time
3. Select trainer
4. Confirm booking

Test Data:
Date: 2025-06-05
Time: 10:00 AM
Trainer: Mike

Expected Result: Session is successfully booked and confirmation is shown.

Actual Result:

Status:

Comments:

Test Case 5: View Workout History

Test Case ID: TC_HISTORY_01

Title: View Workout History

Description: Ensure users can view their past workout sessions.

Preconditions: User is logged in and has completed workout sessions.

Test Steps:
1. Navigate to 'Workout History'
2. View list of past sessions

Test Data: N/A

Expected Result: Past sessions are displayed with details.

Actual Result:

Status:

Comments:
Difference Between Manual Testing and
Automation Testing
1. Introduction
Software testing is a crucial process in the software development lifecycle to ensure the
quality and functionality of applications. There are two main types of testing: Manual
Testing and Automation Testing. Each has its own strengths and use cases.

2. Comparison Table
Aspect Manual Testing Automation Testing
Execution Performed manually by Executed using scripts
testers. and testing tools.
Accuracy Prone to human error. More accurate as it
follows predefined
scripts.
Speed Slower, time-consuming Faster execution,
for repetitive tasks. especially for large test
suites.
Cost Lower initial cost but Higher initial investment,
higher over time due to but cost-effective for
repeated manual effort. long-term use.
Reusability Test cases need to be re- Test scripts can be reused
executed manually every across multiple test
time. cycles.
Suitability Best for exploratory, ad- Best for regression, load,
hoc, and usability testing. and performance testing.
Tool Requirement No tools required. Requires knowledge of
tools like Selenium, QTP,
etc.
Human Observation Good for visual checks Limited in identifying
and user experience visual or UI issues
feedback. without human judgment.

3. Conclusion
Both manual and automation testing have their place in software testing strategies. Manual
testing is essential for understanding user perspectives and testing UI/UX components,
while automation testing is best for repeated and large-scale test executions. A balanced
approach that combines both methods often yields the best results.