Software Testing and Quality Control

Quality Center allows importing defects data, test plan data (test cases), and requirements data to populate the repository. Test Instance data is not directly imported - instances are created when test cases are added to test sets. Option C describes test instances which are generated, not imported.

Coverage Analysis view shows how child requirements are covered by tests, displaying the breakdown based on test coverage status. This helps identify which requirements have adequate test coverage and which don't. Options B, C, and D are not standard Quality Center view names for this analysis.

The Automatic Conversion method can convert the lowest-level child requirements into design steps for test cases. This generates granular test steps from detailed requirements. Option A suggests child steps, not design steps. Option C mentions converting to subject which is not a valid conversion target.

The loop increments #A from 1 to 99 (when #A=99, condition fails and it exits), then RESET fails because #A is already 99, causing abnormal termination. Options A and B are wrong because the program doesn't end normally.

Monkey Testing is a software testing technique where tests are performed randomly with the goal of breaking the system. It simulates a monkey randomly using the application without specific test cases, helping discover unexpected bugs and crashes that structured testing might miss. Automation tools are often used to generate these random inputs.

Ad Hoc testing is an informal testing approach where the tester tries to break the system by randomly exploring its functionality without formal test plans or documentation. Unlike structured testing methods, it relies on the tester's intuition and experience to find defects through spontaneous exploration.

Gorilla Testing is a testing technique where one particular module or component is tested heavily and repeatedly to ensure it works correctly under all conditions. Like a gorilla pounding on one spot, this approach focuses intensive testing effort on a single area rather than broad coverage, often used for critical or complex modules.

Endurance testing specifically targets problems that emerge during extended runtime, such as memory leaks, resource exhaustion, or performance degradation that compound over time. Functional testing validates behavior against requirements, exhaustive testing tries all possible inputs (impractical), and ad hoc testing is informal exploration.

Exhaustive testing is a testing approach that attempts to cover all possible combinations of input values and preconditions for a software element. It theoretically tests every possible path and scenario, though this is often impractical for complex systems due to combinatorial explosion. Random testing selects inputs arbitrarily, while endurance testing checks for issues during prolonged execution, and mutation testing modifies code to verify test suite effectiveness.

Monkey testing is a testing technique where automated tools randomly execute system functionality without specific test cases. It's named after the concept of a monkey randomly interacting with a system. This differs from Ad Hoc testing (unstructured but manual), Gorilla testing (focused repetitive testing of critical features), and Mutation testing (modifying code to test test suite effectiveness).

Ad Hoc testing is an informal, unstructured testing approach where testers randomly execute system functionality to find defects. Unlike other testing types, it relies on tester intuition and lacks formal planning. Endurance testing checks for issues over prolonged execution, Exhaustive testing covers all input combinations, and Mutation testing modifies code to verify test effectiveness.

Gorilla Testing involves testing a single module, node, or function repeatedly and heavily to verify its robustness under extreme conditions. In contrast, Monkey Testing refers to random testing without a test plan, whereas Load and Stress testing assess performance and limits of the entire system under workload.

Endurance testing (also called longevity or soak testing) checks for problems that occur during prolonged system execution. It specifically targets memory leaks, resource exhaustion, and performance degradation that may only appear after extended operation. This differs from stress testing (overloading the system) and exhaustive testing (covering all inputs).

Exhaustive testing is a systematic approach that attempts to cover all possible combinations of input values and preconditions for a software element. It theoretically tests every path, state, and input combination, though this is often impractical for complex systems due to the exponential growth of test cases. This differs from random testing (arbitrary input selection) and mutation testing (code modification).