JAWAHARLAL NEHRU TECHNOLOGICAL UNIVERSITY HYDERABAD MCA 2021 SOFTWARE TESTING METHODOLOGIES Previous Question Paper (July/August - 2021 - R17)

Path testing is a structural white-box testing technique that aims to execute all independent execution paths through a program's source code at least once. By identifying every possible path from the entry point to the exit point, testers ensure that all logical branches and statements are exercised, thereby increasing code coverage and identifying hidden defects in control flow logic.

A Control Flow Graph (CFG) is a graphical representation of all paths that might be traversed through a program during its execution. In a CFG, nodes represent basic blocks (sequences of instructions with one entry and one exit), and directed edges represent the control flow paths between these blocks.

Consider the following simple code snippet:

1: read x;
2: if (x > 0)
3:    print "Positive";
4: else
5:    print "Non-positive";
6: stop;

The corresponding CFG consists of the following nodes and edges:

• Node 1: Start/Read input.
• Node 2: Decision point (if condition).
• Node 3: Print "Positive".
• Node 4: Print "Non-positive".
• Node 5: Stop.

The edges are defined as follows:

In this example, there are two independent paths: (1-2-3-5) and (1-2-4-5). Path testing requires designing test cases to execute both of these paths to ensure complete coverage of the decision logic.

In software testing, dichotomies represent fundamental classifications or contrasting approaches that help structure testing strategies. These pairs define the scope, objectives, and methodologies employed during the software development life cycle.

The primary dichotomies in software testing include:

1. Functional vs. Non-functional Testing: Functional testing verifies that the software performs its intended tasks according to requirements (e.g., unit, integration, and system testing). Non-functional testing evaluates how the system performs, focusing on attributes like performance, scalability, security, and usability.
2. Manual vs. Automated Testing: Manual testing involves human testers executing test cases without automation tools, which is effective for exploratory and usability testing. Automated testing uses scripts and tools to execute repetitive tests, ensuring consistency and efficiency in regression testing.
3. White-box vs. Black-box Testing: White-box testing (structural testing) requires knowledge of the internal code, logic, and architecture to verify paths and data flow. Black-box testing (functional testing) focuses entirely on inputs and expected outputs without visibility into the internal code implementation.
4. Static vs. Dynamic Testing: Static testing involves reviewing or analyzing the code, requirements, and design documents without executing the software (e.g., code reviews, walkthroughs). Dynamic testing involves executing the code on a computer to observe its behavior and identify defects.
5. Positive vs. Negative Testing: Positive testing confirms that the system works as expected when provided with valid inputs. Negative testing attempts to break the system by providing invalid, unexpected, or boundary-level inputs to ensure robustness and error handling.
6. Destructive vs. Constructive Testing: Constructive testing aims to demonstrate that the software works correctly according to specifications. Destructive testing intentionally attempts to find defects and crash the system to determine its breaking points.
7. Verification vs. Validation: Verification ensures that the software is being built correctly according to the design specifications (Are we building the product right?). Validation ensures that the software meets the user's needs and expectations (Are we building the right product?).