Test Strategies (Unit IV)

A strategic approach to software testing

A strategic approach to software testing is a well-planned, systematic method to ensure that testing is effective, efficient, and aligned with project goals. It focuses on quality assurance throughout the software development life cycle (SDLC).

The key elements of a strategic testing approach include:

1. Define Testing Objectives:
   Clearly state what the testing aims to achieve — such as detecting defects, ensuring performance, or verifying compliance with requirements.

2. Develop a Test Plan:
   Outline the scope, resources, schedule, tools, and responsibilities for testing activities.

3. Select the Appropriate Testing Levels:
   Include different levels of testing such as:

   • Unit Testing: Testing individual components.
   • Integration Testing: Checking interaction between modules.
   • System Testing: Evaluating the complete system’s functionality.
   • Acceptance Testing: Ensuring the product meets user needs.

4. Choose Testing Types and Techniques:
   Apply suitable testing methods (functional, performance, security, usability, etc.) and techniques (black-box, white-box, or gray-box).

5. Define Entry and Exit Criteria:
   Specify the conditions that must be met before starting and finishing testing phases.

6. Automate Where Possible:
   Use automation tools to improve efficiency, especially for regression and performance tests.

7. Measure and Monitor:
   Track metrics like defect density, test coverage, and test execution rate to evaluate progress and quality.

8. Continuous Improvement:
   Review results, identify weaknesses, and refine testing processes for future projects.

In short, a strategic approach ensures testing is proactive, structured, and quality-focused, leading to a reliable and maintainable software product.

Test Strategies for Conventional Software

Test strategies for conventional software (developed using traditional models like the Waterfall or V-Model) focus on structured, phase-wise testing that aligns with the software development life cycle.
These strategies ensure systematic defect detection and quality assurance.

The main test strategies include:

1. Unit Testing:

   • Conducted by developers.
   • Tests individual components or modules for correctness.
   • Uses techniques like white-box testing.

2. Integration Testing:

   • Tests the interfaces and interaction between integrated modules.
   • Common approaches:
     • Top-Down Integration
     • Bottom-Up Integration
     • Big-Bang Integration

3. System Testing:

   • Performed after all modules are integrated.
   • Verifies that the complete system meets the specified requirements.
   • Includes functional and non-functional testing (performance, reliability, etc.).

4. Acceptance Testing:

   • Conducted by end users or clients.
   • Ensures the system satisfies business needs and is ready for deployment.
   • Types: Alpha testing (in-house) and Beta testing (user environment).

5. Regression Testing:

   • Re-execution of previously passed tests after changes are made.
   • Ensures that new code has not introduced defects in existing functionality.

6. Validation and Verification Testing:

   • Verification: “Are we building the product right?” — focuses on design and development correctness.
   • Validation: “Are we building the right product?” — ensures final software meets user needs.

7. Performance and Stress Testing:

   • Evaluates the system’s behavior under load, stress, or high-traffic conditions.

In summary, a conventional software test strategy follows a structured, sequential approach, ensuring each phase of development is thoroughly tested before moving to the next — maintaining stability, reliability, and quality in the final product.

Black-Box and White-Box testing

Black-Box Testing and White-Box Testing are two fundamental approaches of software testing that differ mainly in their focus and knowledge of the system’s internal structure.

Black-Box Testing:

Definition:
Black-box testing is a testing technique where the tester does not know the internal workings of the software. The focus is on checking whether the software behaves as expected based on input and output.

Key Points:

• Tests the functionality of the software.
• Testers do not look at the code or internal logic.
• Inputs are given and outputs are verified against expected results.

Techniques Used:

• Equivalence Partitioning
• Boundary Value Analysis
• Decision Table Testing
• State Transition Testing

Advantages:

• Tester’s view is similar to the end-user’s perspective.
• Useful for validation testing (does the system meet requirements?).
• No programming knowledge required.

Disadvantages:

• Cannot find hidden errors in the code structure.
• Limited coverage since internal paths are not tested.

Example:
If you enter a username and password in a login page, the tester checks if correct inputs allow access and wrong ones don’t — without looking at how authentication is coded.

White-Box Testing:

Definition:
White-box testing (also known as Structural or Glass-box testing) examines the internal structure and logic of the code. The tester knows how the system works and designs tests based on the code.

Key Points:

• Tests the internal logic, loops, and conditions in the code.
• Requires programming knowledge.
• Focuses on code coverage (statement, branch, path coverage).

Techniques Used:

• Statement Coverage
• Branch Coverage
• Path Coverage
• Condition Coverage

Advantages:

• Helps find hidden errors in logic or code structure.
• Enables optimization of code paths.
• Ensures complete coverage of possible execution paths.

Disadvantages:

• Time-consuming and requires technical expertise.
• Not practical for large systems with complex code.

Example:
A tester examines the source code of a login function to ensure all branches (correct login, wrong password, blank input) are properly handled.

Comparison Summary:

Aspect	Black-Box Testing	White-Box Testing
Focus	Functionality	Code structure
Tester’s Knowledge	No knowledge of code	Full knowledge of code
Type	Functional testing	Structural testing
Techniques	Equivalence partitioning, boundary value analysis	Statement, branch, path coverage
Used In	Validation testing	Verification testing
Example	Testing login form with inputs	Testing logic inside login code

Validation Testing

Definition:

Validation Testing is the process of checking whether the developed software meets the user’s needs and requirements.
It answers the question:

“Are we building the right product?”

Purpose:

The goal of validation testing is to ensure that the final software system satisfies the intended use and performs as expected in the real-world environment.

Key Features:

• Focuses on external behavior of the system.
• Ensures the software conforms to business requirements.
• Conducted after verification activities.
• Usually performed at the end of the development cycle or during acceptance testing.

Techniques Used in Validation Testing:

1. Functional Testing – Checks if the system’s functions work as specified.
2. System Testing – Tests the complete integrated system as a whole.
3. Acceptance Testing – Conducted by the client or end-users to confirm the software meets their expectations.
4. User Interface (UI) Testing – Ensures that the software is user-friendly and behaves as expected.

Steps in Validation Testing:

1. Review Requirements – Understand what the user expects.
2. Prepare Test Cases – Based on functional specifications.
3. Execute Tests – Run the software in real or simulated environments.
4. Compare Results – Check if actual results match expected outcomes.
5. Report Issues – Log any deviations or defects found.

Example for Validation Testing:

If the requirement states that “The system should allow users to reset their password via email,”
then validation testing will:

• Test if the “Forgot Password” feature exists,
• Check if an email with a reset link is sent,
• Confirm the link correctly allows password change.

Difference Between Verification and Validation:

Aspect	Verification	Validation
Focus	Ensures the product is built correctly	Ensures the right product is built
Question Answered	“Are we building the product right?”	“Are we building the right product?”
Based On	Design and specifications	User needs and requirements
Performed By	Developers and testers	End-users or QA team
Examples	Reviews, walkthroughs, inspections	System testing, acceptance testing