Testing & Why do we need testing:

Software testing is the process of evaluating a software application or system to identify defects,
ensure it meets specified requirements, and verify that it functions correctly. It involves executing
the software under controlled conditions to check for errors, gaps, or any missing functionalities
compared to the expected behavior.

Inspection:
Inspection is a formal, structured review process used in software engineering to identify defects,
improve quality, and ensure compliance with requirements. Unlike casual reviews, inspections
follow a well-defined procedure with roles, checklists, and documentation.

Methods of Inspection:
1. Requirement Analysis Inspection

A systematic review of software requirements documents (SRS, user stories, use cases) to ensure
they are complete, consistent, unambiguous, and testable.

2. Design Inspection
A detailed review of software design documents (architecture, UML diagrams, database schemas) to
ensure they meet requirements and follow best practices.

3. Code Inspection
A line-by-line review of source code to detect bugs, security flaws, and deviations from coding
standards.

4. Test Cases Review

A review of test cases to ensure they cover all requirements and follow best testing practices.

5. User Documentation Inspection

A review of user manuals, help guides, and release notes to ensure clarity, accuracy, and
completeness.

Manual Testing:
Manual testing is a process where human testers execute test cases without the use of automation
tools. It relies on the tester's intuition, experience, and judgment to identify defects, usability issues,
and inconsistencies in the software. This approach is particularly useful for exploratory testing, ad-
hoc scenarios, and usability evaluations where human observation is critical. Since it doesn’t require
scripting, manual testing is flexible and adapts easily to last-minute changes in requirements or
design.

Automated Testing
Automated testing uses specialized tools and scripts (e.g., Selenium) to execute predefined test
cases without human intervention. It is faster, more accurate, and highly efficient for repetitive tasks
such as regression testing, performance testing, and large-scale test suites. Automation reduces
human error and allows tests to run in parallel.
Test Management: Key Activities
Test management is the process of planning, organizing, and controlling testing activities to ensure
software quality. It involves multiple structured phases:

1. Test Planning

Definition: The process of defining the testing strategy, objectives, scope, resources, and schedule

2. Test Cases

Definition: Detailed step-by-step instructions to verify a specific functionality.

Definition: High-level descriptions of what to test, derived from requirements.

Definition: The setup where testing is executed (hardware, software, network).

5. Test Execution

Definition: Running test cases and recording results.

6. Test Closure
Definition: Finalizing testing activities after meeting exit criteria.

Testing Techniques
Testing techniques are systematic methods used to evaluate software for defects, functionality, and
performance. They are broadly classified into Static Testing (without executing code) and Dynamic
Testing (with executing code).
1. Static Testing

Examining software artifacts without executing the code to find defects early.

a) Reviews

A formal or informal evaluation of documents (requirements, design, code) by peers or stakeholders.

b) Inspection

A structured, formal review led by a moderator to detect defects systematically.

An informal meeting where the author explains the document to reviewers.

Testing software by executing it with test data to validate functionality, performance, and security.

a) Black-Box Testing

Testing without knowledge of internal code structure. Focuses on inputs and outputs.
b) White-Box Testing
Testing with knowledge of internal logic (code-level testing).

c) Loop Testing

Validating loops in code (e.g., for, while loops).

d) Data Flow Testing

Tracking data variables through execution paths to find anomalies.

Coverage-Based Testing Techniques

Ensures that every executable statement in the code is executed at least once.

2. Branch Coverage

Ensures that every possible branch (decision outcome) in control structures (if, else, switch) is
executed.
3. Condition Coverage

Ensures that each Boolean sub-expression (condition) is evaluated to both True and False.

4. Multiple Condition Coverage

Tests all possible combinations of conditions in a decision.

Unit Testing:
Unit testing involves verifying individual software components—such as functions, methods, or
classes—in isolation. Developers write test cases to validate that each unit behaves as expected
under various inputs.

Integration Testing:
Integration testing examines how different modules or services interact when combined. It uncovers
defects in interfaces, data exchange, and system behavior that unit testing cannot detect. Three
common approaches exist: top-down (testing high-level modules first with stubs for lower ones),
bottom-up (testing lower-level modules first with drivers for higher ones), and mixed (a hybrid of
both). For instance, testing an e-commerce checkout process might involve integrating the cart,
payment gateway, and inventory systems to ensure seamless data flow. Integration testing is critical
for identifying issues like API mismatches or incorrect data formats.
System Testing:
System testing evaluates the fully integrated application to confirm it meets specified requirements.
It includes:

Alpha testing: Conducted internally by QA teams in a controlled environment.

Beta testing: Performed by real users in real-world settings to gather feedback.

Acceptance testing: Validates whether the system satisfies business needs, often involving
stakeholders.

Performance Testing:
Performance testing assesses the system’s responsiveness, stability, and scalability under varying
loads. Key types include:
Load testing: Measures performance under expected user traffic.

Stress testing: Pushes the system beyond normal limits to identify breaking points.
Security testing: Uncovers vulnerabilities like SQL injection or data leaks.

Accuracy testing: Ensures outputs are correct for given inputs.

For example, a banking app might undergo load testing to handle 10,000 concurrent transactions
without slowdowns. Performance testing is vital for applications where speed and reliability are
critical.

Regression Testing:
Regression testing ensures new code changes do not disrupt existing functionality. Whenever
features are added or bugs are fixed, previously passed test cases are re-executed.