Manual

Testing
Content
 Software Testing
 Types of software testing
 Functional Testing
 Non- functional Testing
 Defect, Error , Failure
 Models in software testing
 SDLC and STLC
 Differences b/w testing types
 Bug and Bug life cycle
 Agile with sprint and scrum
 Software testing
Software testing is the process of evaluating and verifying that a software application or system meets specified requirements
and functions as expected.

Principles of Software Testing

1. Testing Shows Presence of Defects
Testing can show that defects are present, but it cannot prove that the software is defect-free.
2. Exhaustive Testing is Impossible
Testing everything (all combinations of inputs and scenarios) is not feasible. Risk-based and prioritized testing is
necessary.
3. Early Testing
Testing activities should begin as early as possible in the software development lifecycle to identify defects early.
4. Defect Clustering
A small number of modules typically contain the majority of defects (Pareto Principle: 80-20 rule).
5. Pesticide Paradox
Repeating the same test cases will eventually become ineffective in finding new defects. Regularly review and
update test cases.
6. Testing is Context-Dependent
Testing approaches and methods vary depending on the software type, purpose, and environment.
7. Absence of Errors Fallacy
Finding and fixing defects does not guarantee that the system meets user needs and requirements. Validation of
Types of software testing
 Functional Testing
Verifies that the application functions as expected based on the business requirements.
1.Unit Testing
 Tests individual components or modules in isolation.
 Example: Gorilla Testing — focusing on testing one module extensively.
2.Integration Testing
Tests the interaction between integrated modules or components.
Types:
1. Component Integration Testing: Tests interactions between individual components.
2. System Integration Testing: Verifies interactions between multiple systems.
3. End-to-End Integration Testing: Tests the flow of an entire application.
3.System Testing
Validates the complete and fully integrated system.
Types:
1. End-to-End Testing: Tests the system’s workflow from start to finish.
2. Smoke Testing: Verifies basic functionality of the system.
3. Sanity Testing: Ensures changes or fixes work as expected.
4. Monkey Testing: Random inputs are provided to test system stability.
4.Acceptance Testing
Ensures the software meets the end-user requirements before release.
Types:
1. Alpha Testing: Performed internally in a controlled environment.
 Non-Functional Testing
Non-Functional Testing
Focuses on attributes like performance, usability, and reliability.
1.Security Testing
Ensures the application is secure and protects data.
Types:
1. Penetration Testing: Identifies vulnerabilities by simulating attacks.
2. Fuzz Testing: Inputs random data to uncover system weaknesses.
3. Access Control Testing: Validates authorization mechanisms.

2.Performance Testing
Evaluates the system’s speed, stability, and scalability under different conditions.
Types:
4. Load Testing: Tests the system under expected loads.
5. Stress Testing: Tests the system beyond normal capacity.
6. Volume Testing: Examines performance with large data sets.
7. Scalability Testing: Checks the system’s ability to scale.
8. Endurance Testing: Tests stability under sustained usage.
9. Recovery Testing: Evaluates the system's recovery after failure.
 Continue…
4.Usability Testing
Checks user-friendliness and ease of use.
Types:
1. Exploratory Testing: Evaluates the application without predefined test cases.
2. UI Testing: Validates the graphical interface.

5.Compatibility Testing
Verifies the application works across different environments.
Types:
3. Cross-Browser Testing: Ensures compatibility with different web browsers.
4. Cross-Platform Testing: Validates functionality across operating systems or devices.
 Defect , Error, Failure
Term Definition Cause When Detected

Mistake made by a
developer, designer,
Error or tester during Human mistake During development
software
development.

A flaw or
Error in design or During testing or
Defect imperfection in the
coding review
code due to an error.

The deviation of
software behavior
During execution or
Failure from the expected Execution of a defect
usage
outcome when a
defect is executed.
 Models in Software Testing

Software testing models help define the process of testing in a structured manner during the software development lifecycle
(SDLC).
1. Waterfall Model
 A linear and sequential approach where testing is performed after development.
 Process: Requirement → Design → Development → Testing → Deployment → Maintenance.
 Pros: Simple and suitable for well-defined projects.
 Cons: Late testing may lead to delayed defect detection.
 Continue…
2. V-Model (Verification and Validation Model)
 An extension of the Waterfall model where testing is planned parallel to development phases.
 Process: Each development phase (e.g., design, coding) has a corresponding testing phase.
 Pros: Early detection of defects.
 Cons: Not suitable for projects with evolving requirements.
 Continue…
Agile Model
 An iterative and incremental approach where testing is integrated into development.
 Process: Development and testing happen simultaneously in short sprints.
 Pros: Flexible to changing requirements and faster delivery.
 Cons: Requires active collaboration and frequent changes.
 Continue…
4. Iterative Model
 Testing is done in iterations where each cycle improves the system incrementally.
 Process: Initial version → Feedback → Refinement.
 Pros: Issues are resolved quickly after each iteration.
 Cons: Requires more time and effort for testing.
 Continue…
Spiral Model
 Combines iterative and risk-driven approaches, focusing on risk analysis at each phase.
 Process: Planning → Risk Analysis → Engineering → Testing → Review (repeat for every cycle).
 Pros: Effective for high-risk projects.
 Cons: Complex and expensive.
 SDLC and STLC
Phases in SDLC
1.Requirement Analysis: Understand what the system should do.
2.Planning: Define scope, resources, and timelines.
3.Design: Create architecture and detailed system design.
4.Development: Code and build the software.
5.Testing: Test the software for functionality and defects.
6.Deployment: Release the software for use.
7.Maintenance: Fix issues and improve the software post-deployment.

Phases of STLC
1.Requirement Analysis: Understand testing needs based on requirements.
2.Test Planning: Create a test plan, identify tools, and assign resources.
3.Test Case Design: Write test cases and prepare test data.
4.Test Environment Setup: Prepare the testing environment (hardware/software).
5.Test Execution: Execute test cases and log defects.
6.Test Closure: Analyze testing results, generate reports, and close testing activities.
SDLC
STLC
Aspect SDLC STLC
A process focused on testing the
A process for developing high-
Definition software to ensure it meets
quality software systematically.
requirements.
To verify and validate the
To build software that fulfills user
Goal software for defects and quality
and business needs.
assurance.
1. Requirement Analysis
1. Requirement Analysis
2. Planning
2. Test Planning
3. Design
3. Test Case Design
Phases 4. Development
4. Test Environment Setup
5. Testing
5. Test Execution
6. Deployment
6. Test Closure
7. Maintenance
Covers the entire software Specifically focuses on the
Focus lifecycle, from idea to testing and quality aspects of
maintenance. software.
Business Analysts, Developers,
Testers, QA Engineers, and Test
Participants Project Managers, Designers,
Managers.
Testers.
A fully developed and functional Test reports, defect logs, and
Output
software product. quality metrics.
 Differences of testing types
Type of Testing Purpose Scope When
To verify if the build is
High-level, critical Performed on initial
Smoke Testing stable for further
functionalities builds
testing
To verify specific
Narrow, focuses on a After bug fixes or minor
Sanity Testing changes or fixes are
specific area changes
working correctly
To ensure new changes
Extensive, checks old After code changes or
Regression Testing don’t affect existing
and new features new releases
functionality
To verify individual Very focused on a During development
Unit Testing
code components single unit/module (by developers)
To test interaction Focuses on integration After unit testing,
Integration Testing
between components of modules before system testing
To validate the entire End-to-end testing of After integration
System Testing
system functionality the system testing
To verify the software Based on user Before deployment, by
UAT
meets business needs requirements end-users
Controlled
To test internally before
Alpha Testing environment, internal Before beta testing
beta release
 Bug and Bug life cycle
Bug :
A bug (or defect) in software is an error, flaw, or unintended behavior in the software code that causes the system
to behave incorrectly or unexpectedly. Bugs can occur due to issues in coding, logic, design, or even requirements.
Bug Life Cycle (Defect Life Cycle) :
The Bug Life Cycle represents the stages that a bug goes through from detection to resolution. These stages help
track the bug's progress and ensure that it is handled efficiently.
State Description
New Bug is reported and awaits investigation.
Assigned Bug is assigned to a developer for fixing.
Open Developer starts working on the bug.
Developer fixes the bug and the fix is ready
Fixed
for testing.
Retested Testing verifies if the fix is successful.
Closed Bug is resolved and confirmed fixed.
Bug is reopened if the issue persists after
Reopened
fixing.
Deferred Bug is postponed for future resolution.
Rejected Bug is rejected if it's not a valid defect.
Continue…
Continue…
 Agile with scrum and sprint
Agile is a software development methodology based on iterative development, where requirements and solutions
evolve through collaboration between self-organizing cross-functional teams. Scrum and Sprint are integral parts
of Agile, providing frameworks for managing and executing development.

Agile Methodology
Core Principles (from the Agile Manifesto):
Individuals and interactions over processes and tools.
Working software over comprehensive documentation.
Customer collaboration over contract negotiation.
Responding to change over following a plan.

Key Features:
Iterative Development: Work is divided into smaller iterations or cycles.
Collaboration: Teams, stakeholders, and customers work together closely.
Flexibility: Changes in requirements are embraced.
Frequent Deliverables: Software is delivered in small increments.
 Scrum
Scrum is an Agile framework designed to help teams work together efficiently. It divides the work into fixed-
length iterations called Sprints, ensuring frequent delivery of functional product increments.

1.Key Elements of Scrum:

1. Roles:
1. Product Owner: Defines requirements and prioritizes the Product Backlog.
2. Scrum Master: Facilitates the Scrum process and removes impediments.
3. Development Team: Builds the product increment.
2. Artifacts:
1. Product Backlog: A prioritized list of features and tasks.
2. Sprint Backlog: A subset of the Product Backlog to be completed in a Sprint.
3. Increment: A working product delivered at the end of a Sprint.
3. Events:
1. Sprint Planning: Plan the work for the Sprint.
2. Daily Scrum: 15-minute daily stand-up to track progress.
3. Sprint Review: Demonstrate the increment to stakeholders.
4. Sprint Retrospective: Reflect and improve for the next Sprint.
Continue…
 Sprint
A Sprint is a time-boxed period (usually 1-4 weeks) during which the Scrum team works to deliver a potentially
shippable product increment.
1.Key Characteristics:
1. Fixed Duration: Does not exceed the time-box.
2. Focused Work: Team focuses on achieving the Sprint Goal.
3. Iterative: Allows for continuous improvement and incremental delivery.
4. Deliverable: A working product increment that meets the Definition of Done (DoD).
2.Sprint Workflow:
1. Day 1: Sprint Planning to define
the Sprint Goal and Sprint Backlog.
2. Daily Scrum: Short daily meetings
to track progress.
3. Final Day: Sprint Review and
Sprint Retrospective.