MANUAL TESTING

What is Manual Testing?

ISTQB defines testing as “The process within the software development

lifecycle that evaluates the quality of a component or system and related
work products.”

Advantages of Manual Testing

Though manual testing tends to get a bad reputation due to some of its
shortcomings, it is still a beautiful way to vet software.

 Human Perspective: Manual testing lets you think and act like a
real user. You can catch issues with design, usability, or workflows
that automated tools might miss because they don’t “think” like
humans.
 Flexible and Adaptable: You can quickly adjust your tests if
something changes. For example, if a developer makes a last-minute
update, you can test it right away without needing to update any
scripts.
 Great for Exploratory Testing: When you’re trying to discover
unknown bugs, manual testing is perfect. You can poke around and
explore areas that might not be covered by pre-written test cases.
 No Special Setup Required: Manual testing doesn’t need advanced
tools or programming skills. All you need is the software to test, and
you’re good to go.
 Tests Unique Scenarios: Sometimes, users do weird things like
entering emojis in a form or clicking buttons in unexpected ways.
Manual testing helps uncover these edge cases that automation might
overlook.
 No Maintenance Hassles: Automated tests need constant updates
when the software changes. With manual testing, you simply adjust
your approach on the fly without worrying about maintaining test
scripts.
Testing Concepts You Should Know

Here are a few popular manual testing concepts, i.e., testing

terminologies that are used frequently in the testing process, and you
should have an idea of what they are:

Test Scenario
It is a specific situation or condition that a tester creates to test a particular
aspect of a software application. It describes the intended behavior of the
application under certain circumstances.

Test scenarios provide a broader context than individual test cases,

encompassing multiple test cases that collectively validate a specific
functionality, requirement, or use case.

Example: Consider an e-commerce application where the user must

register first. The broader test scenario is user registration.

 Test Scenario: User Registration Process

 Objective: To verify that the user registration process of a website
functions correctly and captures accurate user information.

Test Case
It is a detailed description of a specific test that needs to be executed to
verify a particular aspect or functionality of a software application.

It outlines the steps to be followed, the inputs provided, the expected

outcomes, and any specific conditions or prerequisites required for the test.
Example: There can be multiple test cases for the before-mentioned test
scenario. Here, we are considering one test case where the email id already
exists in the database, and the user should receive an appropriate error
message during registration.

 Test Case: Existing Email

 Preconditions: The user is on the registration page, and the email ID
is already registered.
 Steps:
o Step 1: Enter valid user details, including an already registered
email.
o Step 2: Click the “Register” button.
 Expected Result: An error message indicates that the email is
already in use and the user is not registered.

Test Environment
It is a controlled setup that mimics the real-world conditions under which
software testing is conducted. It includes hardware, software, network
configurations, and other resources necessary for testing the software
application.

Test Data
Test data refers to the input values, configurations, and datasets used to
execute test cases and during software testing.

It helps verify that the software functions correctly and produces accurate
results under different conditions. Test data can include various inputs,
covering both valid and invalid scenarios.

Example:

 Test Case: Verify age validation for user registration (age must be
between 18 and 65).
  Test Data:

Age: 17(below valid range)

Age: 18 (minimum valid age)
Age: 30 (within the valid range)
Age: 65 (maximum valid age)
Age: 66 (above the valid range)

Test Execution
It is to execute the predefined test cases on the software application to
assess its functionality, performance, and other aspects.

The primary goal of test execution is to validate whether the software

behaves as expected, identify defects, and ensure that it meets the defined
requirements.

Test Result
It is the outcome or status of the execution of a specific test case, test
scenario, or a series of tests performed on a software application.

It provides information about whether the software behaved as expected,

whether any defects were identified, and whether the test passed or failed
based on predefined criteria.

Example: Test Case: User Login

 Status: Pass
 Expected Outcome: The user should be able to log in using valid
credentials.
  Actual Outcome: The user successfully logged in and accessed the
dashboard.
 Defects: None identified.
 Comments: The test was executed on Chrome browser, version 92,
using a test user account.
 Attachments: Screenshot of the dashboard after successful login.
 Test Environment:Env to be tested

Defect or Bug
A defect is a flaw, error, or unintended behavior in a software application
that causes it to deviate from its intended functionality.

Defects can arise at various stages of the software development lifecycle-

design, coding, testing, and deployment.

They can manifest as incorrect behavior, crashes, unexpected results, or

other issues that affect the software’s performance, reliability, or user
experience.

Example: A user cannot pay on the checkout page of an e-commerce

website due to a broken “Continue to Payment” button.

Defect Lifecycle
It refers to a defect’s various stages- discovery or resolution in software
development and testing. This lifecycle outlines the steps in identifying,
documenting, prioritizing, fixing, verifying(retesting), and closing defects
to ensure the software meets quality standards.
Test Plan
A test plan is a comprehensive document that outlines the software testing
effort’s approach, scope, objectives, resources, schedule, and deliverables.
It serves as a roadmap or guide for the testing process, detailing how
testing activities will be conducted to ensure that the software meets
quality standards and fulfills its requirements.
Test Strategy
A test strategy is a high-level document that provides a strategic
framework to guide the planning, design, execution, and management of
testing activities throughout the project’s lifecycle.

While a test plan focuses on elaborating the test objectives, a schedule, and
ways to achieve them, the test strategy focuses more on how to go about
the actual testing activities.

Severity and Priority

Severity refers to the extent of a particular defect’s impact on a software
application. It measures the effect of the defect on the software’s
performance and its consequences for overall functionality.

Priority, conversely, is a decisive factor determining the order in which

defects should be addressed. A defect with a higher priority should be
resolved before those with lower priorities.

Verification and Validation

Verification is – are we building the product right? It involves checking
that the software is constructed correctly according to its intended design
and adheres to the established standards and guidelines.

Verification activities ensure the software is consistent with its

documentation and accurately implements the desired functionality.

Validation is – are we building the right product? It involves assessing

that the software fulfills its intended purpose and provides value to its
users.

Validation activities ensure that the software is fit for its intended use in
the real-world environment.
Software Testing Life Cycle (STLC)

STLC stands for Software Testing Life Cycle. It is a systematic and

structured approach to planning, designing, executing, and managing
software testing activities throughout the software development process.

STLC outlines the various phases, tasks, and activities that testing teams
should follow. It ensures the software application meets quality standards,
functions correctly, and delivers a reliable user experience.
Test Case Example

Consider a real-world example in the context of an online shopping

website.

Scenario: Testing the Add to Cart functionality.

Test Case: Verify that a user can add items to the shopping cart
successfully.

Steps:
Step 1: Open the web browser and navigate the online shopping website.
Step 2: Search for a specific product (e.g., “Black T-shirt”) using the
search bar.
Step 3: Click on the corresponding search result.
Step 4: Check that the product details page loads correctly, displaying the
product’s name, price, and description.
Step 5: Click on the “Add to Cart” button.
Step 6: Verify that a confirmation message indicates that the item has been
added to the cart.
Step 7: Click the shopping cart icon.
Step 8: Confirm that the added item is listed with the correct details (name,
price, quantity).
Step 9: Verify that the total cart value is updated to reflect the added item.
Step 10: Close the browser.
Expected Result: The confirmation message appears after clicking “Add
to Cart,” the item is listed in the cart, and the total value is updated
correctly.

Actual Result: The confirmation message appeared, and the total value
was updated correctly.

Defect: Document a defect if discrepancies or issues are found (e.g., the

confirmation message doesn’t appear, the item is not added to the cart, or
the total value is incorrect).
Testing Levels

The testing pyramid below depicts the four broad levels of testing.

 Unit Tests: The smallest software unit (method, few lines of code) is
tested individually.
 Integration Tests: Two or more code units are integrated, and their
interaction and data exchange are tested.
 System Tests: The whole system is combined and tested as a single
unit.
 Acceptance Tests: The final system is tested from the end user’s
perspective.
Types of Testing

Software testing encompasses various manual testing types to assess

different aspects of a software application.

1. Black box testing

2. White box testing
3. Exploratory testing
4. Unit testing
5. Integration testing
6. UI testing
7. UAT
Manual Testing Skills

If you’re planning to begin your journey as a manual tester, then here are
some skills that will help you get ahead:

 Attention to Detail
 Analytical Thinking
 Curiosity and Problem-Solving
 Communication Skills
 Understanding of Software Basics
 Creativity
 Patience
 Organizational Skills
 Collaboration Skills
 Basic Knowledge of Test Tools
 User-Centric Thinking

Conclusion

“In many ways, being a good tester is harder than being a good developer
because testing requires not only a very good understanding of the
development process and its products, but it also demands an ability to
anticipate likely faults and errors”